berget 1.1.0 → 1.2.0

package/dist/src/utils/default-api-key.js

@@ -22,6 +22,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -31,6 +40,8 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const chalk_1 = __importDefault(require("chalk"));
+const api_key_service_1 = require("../services/api-key-service");
+const readline_1 = __importDefault(require("readline"));
 /**
  * Manages the default API key for chat commands
  */
@@ -62,7 +73,9 @@ class DefaultApiKeyManager {
             }
         }
         catch (error) {
-            console.error(chalk_1.default.dim('Failed to load default API key configuration'));
+            if (process.argv.includes('--debug')) {
+                console.error(chalk_1.default.dim('Failed to load default API key configuration'));
+            }
             this.defaultApiKey = null;
         }
     }
@@ -84,20 +97,29 @@ class DefaultApiKeyManager {
             }
         }
         catch (error) {
-            console.error(chalk_1.default.dim('Failed to save default API key configuration'));
+            if (process.argv.includes('--debug')) {
+                console.error(chalk_1.default.dim('Failed to save default API key configuration'));
+            }
         }
     }
     /**
      * Set the default API key
      */
-    setDefaultApiKey(id, name, prefix) {
-        this.defaultApiKey = { id, name, prefix };
+    setDefaultApiKey(id, name, prefix, key) {
+        this.defaultApiKey = { id, name, prefix, key };
         this.saveConfig();
     }
     /**
-     * Get the default API key
+     * Get the default API key string
      */
     getDefaultApiKey() {
+        var _a;
+        return ((_a = this.defaultApiKey) === null || _a === void 0 ? void 0 : _a.key) || null;
+    }
+    /**
+     * Get the default API key data object
+     */
+    getDefaultApiKeyData() {
         return this.defaultApiKey;
     }
     /**
@@ -107,5 +129,109 @@ class DefaultApiKeyManager {
         this.defaultApiKey = null;
         this.saveConfig();
     }
+    /**
+     * Prompts the user to select a default API key if none is set
+     * @returns The selected API key or null if none was selected
+     */
+    promptForDefaultApiKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const isDebug = process.argv.includes('--debug');
+                if (isDebug) {
+                    console.log(chalk_1.default.yellow('DEBUG: promptForDefaultApiKey called'));
+                }
+                // If we already have a default API key, return it
+                if (this.defaultApiKey) {
+                    if (isDebug) {
+                        console.log(chalk_1.default.yellow('DEBUG: Using existing default API key'));
+                    }
+                    return this.defaultApiKey.key;
+                }
+                if (isDebug) {
+                    console.log(chalk_1.default.yellow('DEBUG: No default API key found, getting ApiKeyService'));
+                }
+                const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+                // Get all API keys
+                let apiKeys;
+                try {
+                    if (isDebug) {
+                        console.log(chalk_1.default.yellow('DEBUG: Calling apiKeyService.list()'));
+                    }
+                    apiKeys = yield apiKeyService.list();
+                    if (isDebug) {
+                        console.log(chalk_1.default.yellow(`DEBUG: Got ${apiKeys ? apiKeys.length : 0} API keys`));
+                    }
+                    if (!apiKeys || apiKeys.length === 0) {
+                        console.log(chalk_1.default.yellow('No API keys found. Create one with:'));
+                        console.log(chalk_1.default.blue('  berget api-keys create --name "My Key"'));
+                        return null;
+                    }
+                }
+                catch (error) {
+                    // Check if this is an authentication error
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const isAuthError = errorMessage.includes('Unauthorized') ||
+                        errorMessage.includes('Authentication failed') ||
+                        errorMessage.includes('AUTH_FAILED');
+                    if (isAuthError) {
+                        console.log(chalk_1.default.yellow('Authentication required. Please run `berget auth login` first.'));
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Error fetching API keys:'));
+                        if (error instanceof Error) {
+                            console.log(chalk_1.default.red(error.message));
+                            if (isDebug) {
+                                console.log(chalk_1.default.yellow(`DEBUG: API key list error: ${error.message}`));
+                                console.log(chalk_1.default.yellow(`DEBUG: Stack: ${error.stack}`));
+                            }
+                        }
+                    }
+                    return null;
+                }
+                console.log(chalk_1.default.blue('Select an API key to use as default:'));
+                // Display available API keys
+                apiKeys.forEach((key, index) => {
+                    console.log(`  ${index + 1}. ${key.name} (${key.prefix}...)`);
+                });
+                // Create readline interface for user input
+                const rl = readline_1.default.createInterface({
+                    input: process.stdin,
+                    output: process.stdout
+                });
+                // Prompt for selection
+                const selection = yield new Promise((resolve) => {
+                    rl.question('Enter number (or press Enter to cancel): ', (answer) => {
+                        rl.close();
+                        const num = parseInt(answer.trim(), 10);
+                        if (isNaN(num) || num < 1 || num > apiKeys.length) {
+                            resolve(-1); // Invalid selection
+                        }
+                        else {
+                            resolve(num - 1); // Convert to zero-based index
+                        }
+                    });
+                });
+                if (selection === -1) {
+                    console.log(chalk_1.default.yellow('No API key selected'));
+                    return null;
+                }
+                const selectedKey = apiKeys[selection];
+                // Create a new API key with the selected name
+                const newKey = yield apiKeyService.create({
+                    name: `CLI Default (copy of ${selectedKey.name})`,
+                    description: 'Created automatically by the Berget CLI for default use'
+                });
+                // Save the new key as default
+                this.setDefaultApiKey(newKey.id.toString(), newKey.name, newKey.key.substring(0, 8), // Use first 8 chars as prefix
+                newKey.key);
+                console.log(chalk_1.default.green(`✓ Default API key set to: ${newKey.name}`));
+                return newKey.key;
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('Failed to set default API key:'), error);
+                return null;
+            }
+        });
+    }
 }
 exports.DefaultApiKeyManager = DefaultApiKeyManager;

package/dist/src/utils/error-handler.js

@@ -35,11 +35,11 @@ function handleError(message, error) {
         console.error(chalk_1.default.dim(`Details: ${error.message}`));
     }
     // Check for authentication errors
-    if ((typeof error === 'string' && error.includes('Unauthorized')) ||
-        (error && error.message && error.message.includes('Unauthorized')) ||
-        (error && error.code && error.code === 401)) {
+    if ((typeof error === 'string' && (error.includes('Unauthorized') || error.includes('Authentication failed'))) ||
+        (error && error.message && (error.message.includes('Unauthorized') || error.message.includes('Authentication failed'))) ||
+        (error && error.code && (error.code === 401 || error.code === 'AUTH_FAILED'))) {
         console.error(chalk_1.default.yellow('\nYou need to be logged in to use this command.'));
-        console.error(chalk_1.default.yellow('Run `berget login` to authenticate.'));
+        console.error(chalk_1.default.yellow('Run `berget auth login` to authenticate.'));
     }
 }
 exports.handleError = handleError;

package/index.ts

@@ -3,6 +3,8 @@
 import { program } from 'commander'
 import { registerCommands } from './src/commands'
 import { checkBergetConfig } from './src/utils/config-checker'
+import chalk from 'chalk'
+import { version } from './package.json'
 
 // Set version and description
 program
@@ -17,7 +19,7 @@ program
                  __/ |                      
                 |___/   AI on European terms`
   )
-  .version(process.env.npm_package_version || '0.0.1', '-v, --version')
+  .version(version, '-v, --version')
   .option('--local', 'Use local API endpoint (hidden)', false)
   .option('--debug', 'Enable debug output', false)
 
@@ -27,6 +29,55 @@ registerCommands(program)
 // Check for .bergetconfig if not running a command
 if (process.argv.length <= 2) {
   checkBergetConfig()
+  
+  // Show helpful welcome message
+  console.log(chalk.blue('\nWelcome to the Berget CLI!'));
+  console.log(chalk.blue('Common commands:'));
+  console.log(chalk.blue(`  ${chalk.bold('berget auth login')}      - Log in to Berget`));
+  console.log(chalk.blue(`  ${chalk.bold('berget models list')}     - List available AI models`));
+  console.log(chalk.blue(`  ${chalk.bold('berget chat run')}        - Start a chat session`));
+  console.log(chalk.blue(`  ${chalk.bold('berget api-keys list')}   - List your API keys`));
+  console.log(chalk.blue(`\nRun ${chalk.bold('berget --help')} for a complete list of commands.`));
 }
 
+// Add helpful suggestions for common command mistakes
+const commonMistakes: Record<string, string> = {
+  'login': 'auth login',
+  'logout': 'auth logout',
+  'whoami': 'auth whoami',
+  'list-models': 'models list',
+  'list-keys': 'api-keys list',
+  'create-key': 'api-keys create',
+  'list-clusters': 'clusters list',
+  'usage': 'billing usage'
+};
+
+// Add error handler for unknown commands
+program.on('command:*', (operands) => {
+  const unknownCommand = operands[0] as string;
+  console.error(chalk.red(`Error: unknown command '${unknownCommand}'`));
+  
+  // Check if this is a known mistake and suggest the correct command
+  if (unknownCommand in commonMistakes) {
+    console.log(chalk.yellow(`Did you mean? ${chalk.bold(`berget ${commonMistakes[unknownCommand]}`)}`));
+  } else {
+    // Try to find similar commands
+    const availableCommands = program.commands.map(cmd => cmd.name());
+    const similarCommands = availableCommands.filter(cmd => 
+      cmd.includes(unknownCommand) || unknownCommand.includes(cmd)
+    );
+    
+    if (similarCommands.length > 0) {
+      console.log(chalk.yellow('Similar commands:'));
+      similarCommands.forEach(cmd => {
+        console.log(chalk.yellow(`  ${chalk.bold(`berget ${cmd}`)}`));
+      });
+    }
+    
+    console.log(chalk.blue('\nRun `berget --help` for a list of available commands.'));
+  }
+  
+  process.exit(1);
+});
+
 program.parse(process.argv)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "berget",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "main": "dist/index.js",
   "bin": {
     "berget": "dist/index.js"
@@ -29,6 +29,7 @@
     "fs-extra": "^11.3.0",
     "open": "^9.1.0",
     "openapi-fetch": "^0.9.1",
-    "openapi-typescript": "^6.7.4"
+    "openapi-typescript": "^6.7.4",
+    "readline": "^1.3.0"
   }
 }

package/src/client.ts

@@ -126,21 +126,38 @@ export const createAuthenticatedClient = () => {
           // If we get an auth error, try to refresh the token and retry
           if (result.error) {
             // Detect various forms of authentication errors
-            const isAuthError =
+            let isAuthError = false;
+            
+            try {
               // Standard 401 Unauthorized
-              (typeof result.error === 'object' && result.error.status === 401) ||
+              if (typeof result.error === 'object' && result.error.status === 401) {
+                isAuthError = true;
+              }
               // OAuth specific errors
-              (result.error.error &&
+              else if (result.error.error &&
                 (result.error.error.code === 'invalid_token' ||
                  result.error.error.code === 'token_expired' ||
                  result.error.error.message === 'Invalid API key' ||
                  result.error.error.message?.toLowerCase().includes('token') ||
-                 result.error.error.message?.toLowerCase().includes('unauthorized'))) ||
+                 result.error.error.message?.toLowerCase().includes('unauthorized'))) {
+                isAuthError = true;
+              }
               // Message-based detection as fallback
-              (typeof result.error === 'string' && 
+              else if (typeof result.error === 'string' && 
                 (result.error.toLowerCase().includes('unauthorized') ||
                  result.error.toLowerCase().includes('token') ||
-                 result.error.toLowerCase().includes('auth')))
+                 result.error.toLowerCase().includes('auth'))) {
+                isAuthError = true;
+              }
+            } catch (parseError) {
+              // If we can't parse the error structure, do a simple string check
+              const errorStr = String(result.error);
+              if (errorStr.toLowerCase().includes('unauthorized') ||
+                  errorStr.toLowerCase().includes('token') ||
+                  errorStr.toLowerCase().includes('auth')) {
+                isAuthError = true;
+              }
+            }
 
             if (isAuthError && tokenManager.getRefreshToken()) {
               if (process.argv.includes('--debug')) {

package/src/commands/api-keys.ts

@@ -50,10 +50,15 @@ export function registerApiKeyCommands(program: Command): void {
             ? chalk.green('● Active')
             : chalk.red('● Inactive')
 
+          // Format the prefix to ensure it's not too long
+          const prefixStr = key.prefix.length > 12
+            ? key.prefix.substring(0, 12) + '...'
+            : key.prefix
+
           console.log(
             String(key.id).padEnd(10) +
               key.name.padEnd(25) +
-              key.prefix.padEnd(12) +
+              prefixStr.padEnd(15) +
               status.padEnd(12) +
               key.created.substring(0, 10).padEnd(12) +
               lastUsed
@@ -318,10 +323,15 @@ export function registerApiKeyCommands(program: Command): void {
         
         // Save the default API key
         const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
+        
+        // We need to rotate the key to get the actual key value
+        const rotatedKey = await apiKeyService.rotate(id)
+        
         defaultApiKeyManager.setDefaultApiKey(
           id, 
           selectedKey.name, 
-          selectedKey.prefix
+          selectedKey.prefix,
+          rotatedKey.key
         )
         
         console.log(chalk.green(`✓ API key "${selectedKey.name}" set as default for chat commands`))
@@ -339,9 +349,9 @@ export function registerApiKeyCommands(program: Command): void {
     .action(() => {
       try {
         const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
-        const defaultApiKey = defaultApiKeyManager.getDefaultApiKey()
+        const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData()
         
-        if (!defaultApiKey) {
+        if (!defaultApiKeyData) {
           console.log(chalk.yellow('No default API key set'))
           console.log('')
           console.log('To set a default API key, run:')
@@ -351,9 +361,9 @@ export function registerApiKeyCommands(program: Command): void {
         
         console.log(chalk.bold('Default API key:'))
         console.log('')
-        console.log(`${chalk.dim('ID:')}     ${defaultApiKey.id}`)
-        console.log(`${chalk.dim('Name:')}   ${defaultApiKey.name}`)
-        console.log(`${chalk.dim('Prefix:')} ${defaultApiKey.prefix}`)
+        console.log(`${chalk.dim('ID:')}     ${defaultApiKeyData.id}`)
+        console.log(`${chalk.dim('Name:')}   ${defaultApiKeyData.name}`)
+        console.log(`${chalk.dim('Prefix:')} ${defaultApiKeyData.prefix}`)
         console.log('')
         console.log(chalk.dim('This API key will be used by default when running chat commands'))
         console.log(chalk.dim('You can override it with --api-key or --api-key-id options'))

package/src/commands/chat.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander'
 import chalk from 'chalk'
 import readline from 'readline'
 import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
-import { ChatService, ChatMessage } from '../services/chat-service'
+import { ChatService, ChatMessage, ChatCompletionOptions } from '../services/chat-service'
 import { ApiKeyService } from '../services/api-key-service'
 import { AuthService } from '../services/auth-service'
 import { handleError } from '../utils/error-handler'
@@ -36,7 +36,7 @@ export function registerChatCommands(program: Command): void {
   chat
     .command(SUBCOMMANDS.CHAT.RUN)
     .description('Run a chat session with a specified model')
-    .argument('[model]', 'Model to use (default: berget-70b-instruct)')
+    .argument('[model]', 'Model to use (default: google/gemma-3-27b-it)')
     .option('-s, --system <message>', 'System message')
     .option('-t, --temperature <temp>', 'Temperature (0-1)', parseFloat)
     .option('-m, --max-tokens <tokens>', 'Maximum tokens to generate', parseInt)
@@ -52,17 +52,76 @@ export function registerChatCommands(program: Command): void {
         // Check if we have an API key or need to get one
         let apiKey = options.apiKey
         let apiKeyId = options.apiKeyId
+        
+        // Check for environment variable first
+        const envApiKey = process.env.BERGET_API_KEY;
+        if (envApiKey) {
+          console.log(
+            chalk.dim(`Using API key from BERGET_API_KEY environment variable`)
+          )
+          apiKey = envApiKey;
+        }
+        // If no API key or API key ID provided and no env var, check for default API key
+        else if (!apiKey && !apiKeyId) {
+          try {
+            const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
+            const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData()
+
+            if (defaultApiKeyData) {
+              apiKeyId = defaultApiKeyData.id
+              apiKey = defaultApiKeyData.key
+              
+              if (apiKey) {
+                console.log(
+                  chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
+                )
+              } else {
+                console.log(
+                  chalk.yellow(`Default API key "${defaultApiKeyData.name}" exists but the key value is missing.`)
+                )
+                console.log(
+                  chalk.yellow(`Try rotating the key with: berget api-keys rotate ${defaultApiKeyData.id}`)
+                )
+              }
+            } else {
+              // No default API key, prompt the user to create one
+              console.log(chalk.yellow('No default API key set.'))
 
-        // If no API key or API key ID provided, check for default API key
-        if (!apiKey && !apiKeyId) {
-          const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
-          const defaultApiKey = defaultApiKeyManager.getDefaultApiKey()
+              // Try to prompt for a default API key
+              apiKey = await defaultApiKeyManager.promptForDefaultApiKey()
 
-          if (defaultApiKey) {
-            apiKeyId = defaultApiKey.id
-            console.log(
-              chalk.dim(`Using default API key: ${defaultApiKey.name}`)
-            )
+              if (!apiKey) {
+                console.log(
+                  chalk.red(
+                    'Error: An API key is required to use the chat command.'
+                  )
+                )
+                console.log(chalk.yellow('You can:'))
+                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'
+                  )
+                )
+                return
+              }
+            }
+          } catch (error) {
+            if (process.argv.includes('--debug')) {
+              console.log(
+                chalk.yellow('DEBUG: Error checking default API key:')
+              )
+              console.log(chalk.yellow(String(error)))
+            }
           }
         }
 
@@ -106,9 +165,19 @@ export function registerChatCommands(program: Command): void {
               }
             }
           } catch (error) {
-            console.error(chalk.red('Error fetching API key:'))
-            console.error(error)
-            console.log(chalk.yellow('Using default authentication instead.'))
+            // Check if this is an authentication error
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isAuthError = errorMessage.includes('Unauthorized') || 
+                               errorMessage.includes('Authentication failed') ||
+                               errorMessage.includes('AUTH_FAILED');
+            
+            if (isAuthError) {
+              console.log(chalk.yellow('Authentication required. Please run `berget auth login` first.'));
+            } else {
+              console.error(chalk.red('Error fetching API key:'));
+              console.error(error);
+            }
+            console.log(chalk.yellow('Using default authentication instead.'));
           }
         }
 
@@ -171,14 +240,45 @@ export function registerChatCommands(program: Command): void {
 
             try {
               // Call the API
-              const response = await chatService.createCompletion({
-                model: options.args?.[0] || 'berget-70b-instruct',
+              console.log(chalk.yellow('DEBUG: Preparing completion options'))
+              
+              const completionOptions: ChatCompletionOptions = {
+                model: options.args?.[0] || 'google/gemma-3-27b-it',
                 messages: messages,
                 temperature:
                   options.temperature !== undefined ? options.temperature : 0.7,
                 max_tokens: options.maxTokens || 4096,
-                apiKey: apiKey,
-              })
+              }
+
+              // Only add apiKey if it actually exists
+              if (apiKey) {
+                completionOptions.apiKey = apiKey
+                console.log(chalk.yellow('DEBUG: Using API key from command options or default'))
+              } else {
+                console.log(chalk.yellow('DEBUG: No API key available in chat command'))
+                // If we got this far with defaultApiKeyData but no apiKey, there's a problem
+                const defaultApiKeyManager = DefaultApiKeyManager.getInstance();
+                if (defaultApiKeyManager.getDefaultApiKeyData()) {
+                  console.log(chalk.yellow('DEBUG: Default API key data exists but key is missing'))
+                }
+              }
+
+              // Debug output
+              console.log(chalk.yellow('DEBUG: Completion options:'))
+              console.log(chalk.yellow(JSON.stringify({
+                ...completionOptions,
+                apiKey: completionOptions.apiKey ? '***' : undefined,
+                messages: completionOptions.messages.map((m: any) => ({
+                  role: m.role,
+                  content: m.content.length > 50 ? m.content.substring(0, 50) + '...' : m.content
+                }))
+              }, null, 2)))
+
+              console.log(chalk.yellow('DEBUG: Calling chatService.createCompletion'))
+              
+              const response = await chatService.createCompletion(
+                completionOptions
+              )
 
               // Debug output
               if (program.opts().debug) {
@@ -252,12 +352,12 @@ export function registerChatCommands(program: Command): void {
         // If no API key or API key ID provided, check for default API key
         if (!apiKey && !apiKeyId) {
           const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
-          const defaultApiKey = defaultApiKeyManager.getDefaultApiKey()
+          const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData()
 
-          if (defaultApiKey) {
-            apiKeyId = defaultApiKey.id
+          if (defaultApiKeyData) {
+            apiKeyId = defaultApiKeyData.id
             console.log(
-              chalk.dim(`Using default API key: ${defaultApiKey.name}`)
+              chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
             )
           }
         }

package/src/services/api-key-service.ts

@@ -33,10 +33,10 @@ export interface ApiKeyResponse {
 export class ApiKeyService {
   private static instance: ApiKeyService
   private client = createAuthenticatedClient()
-  
+
   // Command group name for this service
   public static readonly COMMAND_GROUP = COMMAND_GROUPS.API_KEYS
-  
+
   // Subcommands for this service
   public static readonly COMMANDS = SUBCOMMANDS.API_KEYS
 
@@ -56,18 +56,7 @@ export class ApiKeyService {
   public async list(): Promise<ApiKey[]> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys')
-      if (error) {
-        // Check if this is an authentication error
-        const errorObj = typeof error === 'string' ? JSON.parse(error) : error;
-        if (errorObj.status === 401) {
-          throw new Error(JSON.stringify({
-            error: "Authentication failed. Your session may have expired.",
-            code: "AUTH_FAILED",
-            details: "Please run 'berget login' to authenticate again."
-          }))
-        }
-        throw new Error(JSON.stringify(error))
-      }
+      if (error) throw error
       return data || []
     } catch (error) {
       handleError('Failed to list API keys', error)
@@ -82,7 +71,7 @@ export class ApiKeyService {
   public async create(options: CreateApiKeyOptions): Promise<ApiKeyResponse> {
     try {
       const { data, error } = await this.client.POST('/v1/api-keys', {
-        body: options
+        body: options,
       })
       if (error) throw new Error(JSON.stringify(error))
       return data!
@@ -99,7 +88,7 @@ export class ApiKeyService {
   public async delete(id: string): Promise<boolean> {
     try {
       const { error } = await this.client.DELETE('/v1/api-keys/{id}', {
-        params: { path: { id } }
+        params: { path: { id } },
       })
       if (error) throw new Error(JSON.stringify(error))
       return true
@@ -115,9 +104,12 @@ export class ApiKeyService {
    */
   public async rotate(id: string): Promise<ApiKeyResponse> {
     try {
-      const { data, error } = await this.client.PUT('/v1/api-keys/{id}/rotate', {
-        params: { path: { id } }
-      })
+      const { data, error } = await this.client.PUT(
+        '/v1/api-keys/{id}/rotate',
+        {
+          params: { path: { id } },
+        }
+      )
       if (error) throw new Error(JSON.stringify(error))
       return data!
     } catch (error) {
@@ -133,7 +125,7 @@ export class ApiKeyService {
   public async describe(id: string): Promise<any> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys/{id}/usage', {
-        params: { path: { id } }
+        params: { path: { id } },
       })
       if (error) throw new Error(JSON.stringify(error))
       return data