berget 2.2.6 → 2.2.8

package/src/services/chat-service.ts

@@ -1,20 +1,20 @@
-import { createAuthenticatedClient } from '../client'
-import { logger } from '../utils/logger'
+import { createAuthenticatedClient } from '../client';
+import { logger } from '../utils/logger';
 
-export interface ChatMessage {
-  role: 'system' | 'user' | 'assistant'
-  content: string
+export interface ChatCompletionOptions {
+  apiKey?: string;
+  max_tokens?: number;
+  messages: ChatMessage[];
+  model?: string;
+  onChunk?: (chunk: any) => void;
+  stream?: boolean;
+  temperature?: number;
+  top_p?: number;
 }
 
-export interface ChatCompletionOptions {
-  model?: string
-  messages: ChatMessage[]
-  temperature?: number
-  max_tokens?: number
-  stream?: boolean
-  top_p?: number
-  apiKey?: string
-  onChunk?: (chunk: any) => void
+export interface ChatMessage {
+  content: string;
+  role: 'assistant' | 'system' | 'user';
 }
 
 /**
@@ -22,25 +22,25 @@ export interface ChatCompletionOptions {
  * Command group: chat
  */
 export class ChatService {
-  private static instance: ChatService
-  private client = createAuthenticatedClient()
-
   // Command group name for this service
-  public static readonly COMMAND_GROUP = 'chat'
-
+  public static readonly COMMAND_GROUP = 'chat';
   // Subcommands for this service
   public static readonly COMMANDS = {
-    RUN: 'run',
     LIST: 'list',
-  }
+    RUN: 'run',
+  };
+
+  private static instance: ChatService;
+
+  private client = createAuthenticatedClient();
 
   private constructor() {}
 
   public static getInstance(): ChatService {
     if (!ChatService.instance) {
-      ChatService.instance = new ChatService()
+      ChatService.instance = new ChatService();
     }
-    return ChatService.instance
+    return ChatService.instance;
   }
 
   /**
@@ -49,19 +49,19 @@ export class ChatService {
    */
   public async createCompletion(options: ChatCompletionOptions): Promise<any> {
     try {
-      logger.debug('Starting createCompletion method')
+      logger.debug('Starting createCompletion method');
 
       // Initialize options if undefined
-      const optionsCopy = options ? { ...options } : { messages: [] }
+      const optionsCopy = options ? { ...options } : { messages: [] };
 
       // Check if messages are defined
       if (!optionsCopy.messages || !Array.isArray(optionsCopy.messages)) {
-        logger.error('messages is undefined or not an array')
-        optionsCopy.messages = []
+        logger.error('messages is undefined or not an array');
+        optionsCopy.messages = [];
       }
 
       // Log the options object
-      logger.debug('Starting createCompletion with options:')
+      logger.debug('Starting createCompletion with options:');
       try {
         logger.debug(
           JSON.stringify(
@@ -75,120 +75,108 @@ export class ChatService {
             null,
             2,
           ),
-        )
+        );
       } catch (error) {
-        logger.error('Failed to stringify options:', error)
+        logger.error('Failed to stringify options:', error);
       }
 
-      const headers: Record<string, string> = {}
+      const headers: Record<string, string> = {};
 
       // First try to use the authenticated client (with refresh token support)
       // Only fall back to API key flow if explicitly requested or no auth tokens available
-      const { TokenManager } = await import('../utils/token-manager')
-      const tokenManagerInstance = TokenManager.getInstance()
-      const hasValidAuth = tokenManagerInstance.getAccessToken() && !tokenManagerInstance.isTokenExpired()
-      
-      const envApiKeyForAuth = process.env.BERGET_API_KEY
-      const hasExplicitApiKey = !!optionsCopy.apiKey || !!envApiKeyForAuth
+      const { TokenManager } = await import('../utils/token-manager');
+      const tokenManagerInstance = TokenManager.getInstance();
+      const hasValidAuth =
+        tokenManagerInstance.getAccessToken() && !tokenManagerInstance.isTokenExpired();
+
+      const environmentApiKeyForAuth = process.env.BERGET_API_KEY;
+      const hasExplicitApiKey = !!optionsCopy.apiKey || !!environmentApiKeyForAuth;
 
       // If we have valid auth tokens and no explicit API key, use authenticated client
       if (hasValidAuth && !hasExplicitApiKey) {
-        logger.debug('Using authenticated client with refresh token support')
+        logger.debug('Using authenticated client with refresh token support');
         // Create a copy without apiKey to let the authenticated client handle auth automatically
-        const { apiKey, ...optionsWithoutKey } = optionsCopy
-        return this.executeCompletion(optionsWithoutKey, {})
+        const { apiKey: _apiKey, ...optionsWithoutKey } = optionsCopy;
+        return this.executeCompletion(optionsWithoutKey, {});
       }
 
       // Check for environment variables first - prioritize this over everything else
-      const envApiKey = process.env.BERGET_API_KEY
-      if (envApiKey) {
-        logger.debug('Using API key from BERGET_API_KEY environment variable')
-        optionsCopy.apiKey = envApiKey
+      const environmentApiKey = process.env.BERGET_API_KEY;
+      if (environmentApiKey) {
+        logger.debug('Using API key from BERGET_API_KEY environment variable');
+        optionsCopy.apiKey = environmentApiKey;
         // Skip the default API key logic if we already have a key
-        return this.executeCompletion(optionsCopy, headers)
+        return this.executeCompletion(optionsCopy, headers);
       }
       // If API key is already provided, use it directly
       else if (optionsCopy.apiKey) {
-        logger.debug('Using API key provided in options')
+        logger.debug('Using API key provided in options');
         // Skip the default API key logic if we already have a key
-        return this.executeCompletion(optionsCopy, headers)
+        return this.executeCompletion(optionsCopy, headers);
       }
       // Only try to get the default API key if no API key is provided and no env var is set
       else {
-        logger.debug('No API key provided, trying to get default')
+        logger.debug('No API key provided, trying to get default');
 
         try {
           // Import the DefaultApiKeyManager directly
-          logger.debug('Importing DefaultApiKeyManager')
+          logger.debug('Importing DefaultApiKeyManager');
 
-          const DefaultApiKeyManager = (
-            await import('../utils/default-api-key')
-          ).DefaultApiKeyManager
-          const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
+          const { DefaultApiKeyManager } = await import('../utils/default-api-key');
+          const defaultApiKeyManager = DefaultApiKeyManager.getInstance();
 
-          logger.debug('Got DefaultApiKeyManager instance')
+          logger.debug('Got DefaultApiKeyManager instance');
 
           // Try to get the default API key
-          logger.debug('Calling promptForDefaultApiKey')
+          logger.debug('Calling promptForDefaultApiKey');
 
-          const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData()
+          const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData();
           const apiKey =
-            defaultApiKeyData?.key ||
-            (await defaultApiKeyManager.promptForDefaultApiKey())
+            defaultApiKeyData?.key || (await defaultApiKeyManager.promptForDefaultApiKey());
 
-          logger.debug(`Default API key data exists: ${!!defaultApiKeyData}`)
-          logger.debug(
-            `promptForDefaultApiKey returned: ${apiKey ? 'a key' : 'null'}`,
-          )
+          logger.debug(`Default API key data exists: ${!!defaultApiKeyData}`);
+          logger.debug(`promptForDefaultApiKey returned: ${apiKey ? 'a key' : 'null'}`);
 
           if (apiKey) {
-            logger.debug('Using API key from default API key manager')
-            optionsCopy.apiKey = apiKey
+            logger.debug('Using API key from default API key manager');
+            optionsCopy.apiKey = apiKey;
           } else {
-            logger.warn('No API key available. You need to either:')
-            logger.warn(
-              '1. Create an API key with: berget api-keys create --name "My Key"',
-            )
-            logger.warn(
-              '2. Set a default API key with: berget api-keys set-default <id>',
-            )
-            logger.warn('3. Provide an API key with the --api-key option')
-            logger.warn('4. Set the BERGET_API_KEY environment variable')
-            logger.warn('\nExample:')
-            logger.warn('  export BERGET_API_KEY=your_api_key_here')
-            logger.warn('  # or for a single command:')
-            logger.warn(
-              '  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')
+            logger.warn('No API key available. You need to either:');
+            logger.warn('1. Create an API key with: berget api-keys create --name "My Key"');
+            logger.warn('2. Set a default API key with: berget api-keys set-default <id>');
+            logger.warn('3. Provide an API key with the --api-key option');
+            logger.warn('4. Set the BERGET_API_KEY environment variable');
+            logger.warn('\nExample:');
+            logger.warn('  export BERGET_API_KEY=your_api_key_here');
+            logger.warn('  # or for a single command:');
+            logger.warn('  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
-          logger.debug('Setting API key in options')
+          logger.debug('Setting API key in options');
 
           // Only set the API key if it's not null
           if (apiKey) {
-            optionsCopy.apiKey = apiKey
+            optionsCopy.apiKey = apiKey;
           }
         } catch (error) {
-          logger.error('Error getting API key:')
+          logger.error('Error getting API key:');
           if (error instanceof Error) {
-            logger.error(error.message)
+            logger.error(error.message);
           }
-          logger.warn(
-            'Please create an API key with: berget api-keys create --name "My Key"',
-          )
-          throw new Error('Failed to get API key')
+          logger.warn('Please create an API key with: berget api-keys create --name "My Key"');
+          throw new Error('Failed to get API key');
         }
       }
 
       // Set default model if not provided
       if (!optionsCopy.model) {
-        logger.debug('No model specified, using default: google/gemma-3-27b-it')
-        optionsCopy.model = 'google/gemma-3-27b-it'
+        logger.debug('No model specified, using default: google/gemma-3-27b-it');
+        optionsCopy.model = 'google/gemma-3-27b-it';
       }
 
-      logger.debug('Chat completion options:')
+      logger.debug('Chat completion options:');
       logger.debug(
         JSON.stringify(
           {
@@ -198,28 +186,77 @@ export class ChatService {
           null,
           2,
         ),
-      )
+      );
 
-      return this.executeCompletion(optionsCopy, headers)
+      return this.executeCompletion(optionsCopy, headers);
     } catch (error) {
       // Improved error handling
-      let errorMessage = 'Failed to create chat completion'
+      let errorMessage = 'Failed to create chat completion';
 
       if (error instanceof Error) {
         try {
           // Try to parse the error message as JSON
-          const parsedError = JSON.parse(error.message)
+          const parsedError = JSON.parse(error.message);
           if (parsedError.error && parsedError.error.message) {
-            errorMessage = `Chat error: ${parsedError.error.message}`
+            errorMessage = `Chat error: ${parsedError.error.message}`;
+          }
+        } catch {
+          // If parsing fails, use the original error message
+          errorMessage = `Chat error: ${error.message}`;
+        }
+      }
+
+      logger.error(errorMessage);
+      throw new Error(errorMessage);
+    }
+  }
+
+  /**
+   * List available models
+   * Command: berget chat list
+   */
+  public async listModels(apiKey?: string): Promise<any> {
+    try {
+      // Check for environment variable first, then fallback to provided API key
+      const environmentApiKey = process.env.BERGET_API_KEY;
+      const effectiveApiKey = environmentApiKey || apiKey;
+
+      if (effectiveApiKey) {
+        const headers = {
+          Authorization: effectiveApiKey,
+        };
+
+        const { data, error } = await this.client.GET('/v1/models', { headers });
+        if (error) throw new Error(JSON.stringify(error));
+        return data;
+      } else {
+        const { data, error } = await this.client.GET('/v1/models');
+        if (error) throw new Error(JSON.stringify(error));
+        return data;
+      }
+    } catch (error) {
+      // Improved error handling
+      let errorMessage = 'Failed to list models';
+
+      if (error instanceof Error) {
+        try {
+          // Try to parse the error message as JSON
+          const parsedError = JSON.parse(error.message);
+          if (parsedError.error) {
+            errorMessage = `Models error: ${
+              typeof parsedError.error === 'string'
+                ? parsedError.error
+                : parsedError.error.message || JSON.stringify(parsedError.error)
+            }`;
           }
-        } catch (e) {
+        } catch {
           // If parsing fails, use the original error message
-          errorMessage = `Chat error: ${error.message}`
+          errorMessage = `Models error: ${error.message}`;
         }
       }
 
-      logger.error(errorMessage)
-      throw new Error(errorMessage)
+      logger.error(errorMessage);
+      throw new Error(errorMessage);
     }
   }
 
@@ -237,13 +274,13 @@ export class ChatService {
       // If an API key is provided, use it for this request
       if (options.apiKey) {
         // API keys should be sent directly, not with Bearer prefix
-        headers['Authorization'] = options.apiKey
+        headers['Authorization'] = options.apiKey;
       }
 
       // Remove apiKey and onChunk from options before sending to API
-      const { apiKey, onChunk, ...requestOptions } = options
+      const { apiKey: _apiKey, onChunk, ...requestOptions } = options;
 
-      logger.debug('Request options:')
+      logger.debug('Request options:');
       logger.debug(
         JSON.stringify(
           {
@@ -255,80 +292,52 @@ export class ChatService {
           null,
           2,
         ),
-      )
+      );
 
       // Handle streaming responses differently
       if (requestOptions.stream && onChunk) {
-        return await this.handleStreamingResponse(
-          { ...requestOptions, onChunk },
-          headers,
-        )
+        return await this.handleStreamingResponse({ ...requestOptions, onChunk }, headers);
       } else {
         // Ensure model is always defined for the API call
         const requestBody = {
           ...requestOptions,
           model: requestOptions.model || 'google/gemma-3-27b-it',
-        }
+        };
 
         // Debug the headers being sent
-        logger.debug('Headers being sent:')
-        logger.debug(JSON.stringify(headers, null, 2))
+        logger.debug('Headers being sent:');
+        logger.debug(JSON.stringify(headers, null, 2));
 
         const response = await this.client.POST('/v1/chat/completions', {
           body: requestBody,
           headers,
-        })
+        });
 
         // Check if response has an error property
-        const responseAny = response as any
-        if (responseAny && responseAny.error)
-          throw new Error(JSON.stringify(responseAny.error))
+        const responseAny = response as any;
+        if (responseAny && responseAny.error) throw new Error(JSON.stringify(responseAny.error));
 
-        logger.debug('API response:')
-        logger.debug(JSON.stringify(response, null, 2))
+        logger.debug('API response:');
+        logger.debug(JSON.stringify(response, null, 2));
 
         // Output the complete response data for debugging
-        logger.debug('Complete response data:')
-        logger.debug(JSON.stringify(response.data, null, 2))
+        logger.debug('Complete response data:');
+        logger.debug(JSON.stringify(response.data, null, 2));
 
-        return response.data
+        return response.data;
       }
     } catch (requestError) {
       logger.debug(
         `Request error: ${
-          requestError instanceof Error
-            ? requestError.message
-            : String(requestError)
+          requestError instanceof Error ? requestError.message : String(requestError)
         }`,
-      )
-      throw requestError
+      );
+      throw requestError;
     }
   }
 
   /**
-   * Handle the case when no API key is available
-   */
-  private handleNoApiKey(): never {
-    // We've exhausted all options for getting an API key
-    logger.warn('No API key available. You need to either:')
-    logger.warn(
-      '1. Create an API key with: berget api-keys create --name "My Key"',
-    )
-    logger.warn(
-      '2. Set a default API key with: berget api-keys set-default <id>',
-    )
-    logger.warn('3. Provide an API key with the --api-key option')
-    logger.warn('4. Set the BERGET_API_KEY environment variable')
-    logger.warn('\nExample:')
-    logger.warn('  export BERGET_API_KEY=your_api_key_here')
-    logger.warn('  # or for a single command:')
-    logger.warn(
-      '  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.',
-    )
-  }
+
 
   /**
    * Handle streaming response from the API
@@ -341,175 +350,185 @@ export class ChatService {
     headers: Record<string, string>,
   ): Promise<any> {
     // Use the same base URL as the client
-    const baseUrl = process.env.API_BASE_URL || 'https://api.berget.ai'
-    const url = new URL(`${baseUrl}/v1/chat/completions`)
+    const baseUrl = process.env.API_BASE_URL || 'https://api.berget.ai';
+    const url = new URL(`${baseUrl}/v1/chat/completions`);
 
     try {
-      logger.debug(`Making streaming request to: ${url.toString()}`)
-      logger.debug(`Headers:`, JSON.stringify(headers, null, 2))
-      logger.debug(`Body:`, JSON.stringify(options, null, 2))
+      logger.debug(`Making streaming request to: ${url.toString()}`);
+      logger.debug(`Headers:`, JSON.stringify(headers, null, 2));
+      logger.debug(`Body:`, JSON.stringify(options, null, 2));
 
       // Make fetch request directly to handle streaming
       const response = await fetch(url.toString(), {
-        method: 'POST',
+        body: JSON.stringify(options),
         headers: {
-          'Content-Type': 'application/json',
           Accept: 'text/event-stream',
+          'Content-Type': 'application/json',
           ...headers,
         },
-        body: JSON.stringify(options),
-      })
+        method: 'POST',
+      });
 
-      logger.debug(`Response status: ${response.status}`)
+      logger.debug(`Response status: ${response.status}`);
       logger.debug(
         `Response headers:`,
         JSON.stringify(Object.fromEntries(response.headers.entries()), null, 2),
-      )
+      );
 
       if (!response.ok) {
-        const errorText = await response.text()
-        logger.error(
-          `Stream request failed: ${response.status} ${response.statusText}`,
-        )
-        logger.error(`Error response: ${errorText}`)
+        const errorText = await response.text();
+        logger.error(`Stream request failed: ${response.status} ${response.statusText}`);
+        logger.error(`Error response: ${errorText}`);
         throw new Error(
           `Stream request failed: ${response.status} ${response.statusText} - ${errorText}`,
-        )
+        );
       }
 
       if (!response.body) {
-        throw new Error('No response body received')
+        throw new Error('No response body received');
       }
 
       // Process the stream
-      const reader = response.body.getReader()
-      const decoder = new TextDecoder()
-      let fullContent = ''
-      let fullResponse: any = null
-      let buffer = '' // Buffer to accumulate partial JSON data
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let fullContent = '';
+      let fullResponse: any = null;
+      let buffer = ''; // Buffer to accumulate partial JSON data
 
       while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
+        const { done, value } = await reader.read();
+        if (done) break;
 
-        const chunk = decoder.decode(value, { stream: true })
-        logger.debug(`Received chunk: ${chunk.length} bytes`)
+        const chunk = decoder.decode(value, { stream: true });
+        logger.debug(`Received chunk: ${chunk.length} bytes`);
 
         // Add chunk to buffer
-        buffer += chunk
-        logger.debug(`Added chunk to buffer. Buffer length: ${buffer.length}`)
+        buffer += chunk;
+        logger.debug(`Added chunk to buffer. Buffer length: ${buffer.length}`);
 
         // Process the buffer - it may contain multiple SSE events
-        const lines = buffer.split('\n')
-        logger.debug(`Processing ${lines.length} lines from buffer`)
-        
+        const lines = buffer.split('\n');
+        logger.debug(`Processing ${lines.length} lines from buffer`);
+
         // Keep track of processed lines to update buffer
-        let processedLines = 0
-        
-        for (let i = 0; i < lines.length; i++) {
-          const line = lines[i]
-          logger.debug(`Line ${i}: "${line}"`)
-          
+        let processedLines = 0;
+
+        for (const [index, line] of lines.entries()) {
+          logger.debug(`Line ${index}: "${line}"`);
+
           if (line.startsWith('data:')) {
-            const jsonData = line.slice(5).trim()
-            logger.debug(`Extracted JSON data: "${jsonData}"`)
+            const jsonData = line.slice(5).trim();
+            logger.debug(`Extracted JSON data: "${jsonData}"`);
 
             // Skip empty data or [DONE] marker
             if (jsonData === '' || jsonData === '[DONE]') {
-              logger.debug(`Skipping empty data or [DONE] marker`)
-              processedLines = i + 1
-              continue
+              logger.debug(`Skipping empty data or [DONE] marker`);
+              processedLines = index + 1;
+              continue;
             }
 
             // Check if JSON looks complete (basic validation)
             if (!jsonData.startsWith('{')) {
-              logger.warn(`JSON data doesn't start with '{', might be partial: "${jsonData.substring(0, 50)}..."`)
+              logger.warn(
+                `JSON data doesn't start with '{', might be partial: "${jsonData.slice(0, 50)}..."`,
+              );
               // Don't process this line yet, keep it in buffer
-              break
+              break;
             }
 
             // Count braces to check if JSON is complete
-            let braceCount = 0
-            let inString = false
-            let escaped = false
-            
-            for (let j = 0; j < jsonData.length; j++) {
-              const char = jsonData[j]
+            let braceCount = 0;
+            let inString = false;
+            let escaped = false;
+
+            for (const char of jsonData) {
               if (escaped) {
-                escaped = false
-                continue
+                escaped = false;
+                continue;
               }
               if (char === '\\') {
-                escaped = true
-                continue
+                escaped = true;
+                continue;
               }
               if (char === '"') {
-                inString = !inString
-                continue
+                inString = !inString;
+                continue;
               }
               if (!inString && char === '{') {
-                braceCount++
+                braceCount++;
               } else if (!inString && char === '}') {
-                braceCount--
+                braceCount--;
               }
             }
-            
+
             if (braceCount !== 0) {
-              logger.warn(`JSON braces don't balance (${braceCount}), treating as partial: "${jsonData.substring(0, 50)}..."`)
+              logger.warn(
+                `JSON braces don't balance (${braceCount}), treating as partial: "${jsonData.slice(0, 50)}..."`,
+              );
               // Don't process this line yet, keep it in buffer
-              break
+              break;
             }
 
             try {
-              logger.debug(`Attempting to parse JSON of length: ${jsonData.length}`)
-              const parsedData = JSON.parse(jsonData)
-              logger.debug(`Successfully parsed JSON: ${JSON.stringify(parsedData, null, 2)}`)
-              processedLines = i + 1 // Mark this line as processed
+              logger.debug(`Attempting to parse JSON of length: ${jsonData.length}`);
+              const parsedData = JSON.parse(jsonData);
+              logger.debug(`Successfully parsed JSON: ${JSON.stringify(parsedData, null, 2)}`);
+              processedLines = index + 1; // Mark this line as processed
 
               // Call the onChunk callback with the parsed data
               if (options.onChunk) {
-                options.onChunk(parsedData)
+                options.onChunk(parsedData);
               }
 
               // Keep track of the full response
               if (!fullResponse) {
-                fullResponse = parsedData
+                fullResponse = parsedData;
               } else if (
                 parsedData.choices &&
                 parsedData.choices[0] &&
-                parsedData.choices[0].delta
+                parsedData.choices[0].delta && // Accumulate content for the full response
+                parsedData.choices[0].delta.content
               ) {
-                // Accumulate content for the full response
-                if (parsedData.choices[0].delta.content) {
-                  fullContent += parsedData.choices[0].delta.content
-                }
+                fullContent += parsedData.choices[0].delta.content;
               }
-            } catch (e) {
-              logger.error(`Error parsing chunk: ${e}`)
-              logger.error(`JSON parse error at position ${(e as any).message?.match(/position (\d+)/)?.[1] || 'unknown'}`)
-              logger.error(`Problematic chunk length: ${jsonData.length}`)
-              logger.error(`Problematic chunk content: "${jsonData}"`)
-              logger.error(`Chunk starts with: "${jsonData.substring(0, 50)}..."`)
-              logger.error(`Chunk ends with: "...${jsonData.substring(jsonData.length - 50)}"`)
-              
+            } catch (error) {
+              logger.error(`Error parsing chunk: ${error}`);
+              logger.error(
+                `JSON parse error at position ${(error as any).message?.match(/position (\d+)/)?.[1] || 'unknown'}`,
+              );
+              logger.error(`Problematic chunk length: ${jsonData.length}`);
+              logger.error(`Problematic chunk content: "${jsonData}"`);
+              logger.error(`Chunk starts with: "${jsonData.slice(0, 50)}..."`);
+              logger.error(
+                `Chunk ends with: "...${jsonData.slice(Math.max(0, jsonData.length - 50))}"`,
+              );
+
               // Show character codes around the error position
-              const errorPos = parseInt((e as any).message?.match(/position (\d+)/)?.[1] || '0')
+              const errorPos = Number.parseInt(
+                (error as any).message?.match(/position (\d+)/)?.[1] || '0',
+              );
               if (errorPos > 0) {
-                const start = Math.max(0, errorPos - 20)
-                const end = Math.min(jsonData.length, errorPos + 20)
-                logger.error(`Context around error position ${errorPos}:`)
-                logger.error(`"${jsonData.substring(start, end)}"`)
-                logger.error(`Character codes: ${Array.from(jsonData.substring(start, end)).map(c => c.charCodeAt(0)).join(' ')}`)
+                const start = Math.max(0, errorPos - 20);
+                const end = Math.min(jsonData.length, errorPos + 20);
+                logger.error(`Context around error position ${errorPos}:`);
+                logger.error(`"${jsonData.substring(start, end)}"`);
+                logger.error(
+                  `Character codes: ${[...jsonData.substring(start, end)]
+                    .map((c) => c.charCodeAt(0))
+                    .join(' ')}`,
+                );
               }
             }
           }
         }
-        
+
         // Update buffer to only contain unprocessed lines
         if (processedLines > 0) {
-          const remainingLines = lines.slice(processedLines)
-          buffer = remainingLines.join('\n')
-          logger.debug(`Updated buffer. Remaining lines: ${remainingLines.length}, Buffer length: ${buffer.length}`)
+          const remainingLines = lines.slice(processedLines);
+          buffer = remainingLines.join('\n');
+          logger.debug(
+            `Updated buffer. Remaining lines: ${remainingLines.length}, Buffer length: ${buffer.length}`,
+          );
         }
       }
 
@@ -517,72 +536,19 @@ export class ChatService {
       if (fullResponse) {
         if (fullContent) {
           fullResponse.choices[0].message = {
-            role: 'assistant',
             content: fullContent,
-          }
+            role: 'assistant',
+          };
         }
-        return fullResponse
+        return fullResponse;
       }
 
       return {
-        choices: [{ message: { role: 'assistant', content: fullContent } }],
-      }
-    } catch (error) {
-      logger.error(
-        `Streaming error: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      )
-      throw error
-    }
-  }
-
-  /**
-   * List available models
-   * Command: berget chat list
-   */
-  public async listModels(apiKey?: string): Promise<any> {
-    try {
-      // 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: effectiveApiKey,
-        }
-
-        const { data, error } = await this.client.GET('/v1/models', { headers })
-        if (error) throw new Error(JSON.stringify(error))
-        return data
-      } else {
-        const { data, error } = await this.client.GET('/v1/models')
-        if (error) throw new Error(JSON.stringify(error))
-        return data
-      }
+        choices: [{ message: { content: fullContent, role: 'assistant' } }],
+      };
     } catch (error) {
-      // Improved error handling
-      let errorMessage = 'Failed to list models'
-
-      if (error instanceof Error) {
-        try {
-          // Try to parse the error message as JSON
-          const parsedError = JSON.parse(error.message)
-          if (parsedError.error) {
-            errorMessage = `Models error: ${
-              typeof parsedError.error === 'string'
-                ? parsedError.error
-                : parsedError.error.message || JSON.stringify(parsedError.error)
-            }`
-          }
-        } catch (e) {
-          // If parsing fails, use the original error message
-          errorMessage = `Models error: ${error.message}`
-        }
-      }
-
-      logger.error(errorMessage)
-      throw new Error(errorMessage)
+      logger.error(`Streaming error: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
     }
   }
 }