berget 1.3.1 → 2.0.0

package/src/commands/chat.ts

@@ -2,7 +2,11 @@ import { Command } from 'commander'
 import chalk from 'chalk'
 import readline from 'readline'
 import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
-import { ChatService, ChatMessage, ChatCompletionOptions } 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'
@@ -37,66 +41,75 @@ 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: google/gemma-3-27b-it)')
+    .argument('[model]', 'Model to use (default: openai/gpt-oss)')
+    .argument('[message]', 'Message to send directly (skips interactive mode)')
     .option('-s, --system <message>', 'System message')
     .option('-t, --temperature <temp>', 'Temperature (0-1)', parseFloat)
     .option('-m, --max-tokens <tokens>', 'Maximum tokens to generate', parseInt)
     .option('-k, --api-key <key>', 'API key to use for this chat session')
     .option(
       '--api-key-id <id>',
-      'ID of the API key to use from your saved keys'
+      'ID of the API key to use from your saved keys',
     )
-    .option('--stream', 'Stream the response')
-    .action(async (options) => {
+    .option(
+      '--no-stream',
+      'Disable streaming (streaming is enabled by default)',
+    )
+    .action(async (model, message, options) => {
       try {
         const chatService = ChatService.getInstance()
 
         // 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;
+        const envApiKey = process.env.BERGET_API_KEY
         if (envApiKey) {
           console.log(
-            chalk.dim(`Using API key from BERGET_API_KEY environment variable`)
+            chalk.dim(`Using API key from BERGET_API_KEY environment variable`),
           )
-          apiKey = envApiKey;
-          
+          apiKey = envApiKey
+
           // Debug the API key (first few characters only)
           if (process.argv.includes('--debug')) {
             console.log(
-              chalk.yellow(`DEBUG: API key from env starts with: ${envApiKey.substring(0, 4)}...`)
+              chalk.yellow(
+                `DEBUG: API key from env starts with: ${envApiKey.substring(0, 4)}...`,
+              ),
             )
           }
         }
         // If API key is already provided via command line, use it
         else if (options.apiKey) {
-          console.log(
-            chalk.dim(`Using API key from command line argument`)
-          )
-          apiKey = options.apiKey;
+          console.log(chalk.dim(`Using API key from command line argument`))
+          apiKey = options.apiKey
         }
         // 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()
+            const defaultApiKeyData =
+              defaultApiKeyManager.getDefaultApiKeyData()
 
             if (defaultApiKeyData) {
               apiKeyId = defaultApiKeyData.id
               apiKey = defaultApiKeyData.key
-              
+
               if (apiKey) {
                 console.log(
-                  chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
+                  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.`)
+                  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}`)
+                  chalk.yellow(
+                    `Try rotating the key with: berget api-keys rotate ${defaultApiKeyData.id}`,
+                  ),
                 )
               }
             } else {
@@ -109,24 +122,24 @@ export function registerChatCommands(program: Command): void {
               if (!apiKey) {
                 console.log(
                   chalk.red(
-                    'Error: An API key is required to use the chat command.'
-                  )
+                    '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"'
-                  )
+                    '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>'
-                  )
+                    '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'
-                  )
+                    '3. Provide an API key with the --api-key option',
+                  ),
                 )
                 return
               }
@@ -134,7 +147,7 @@ export function registerChatCommands(program: Command): void {
           } catch (error) {
             if (process.argv.includes('--debug')) {
               console.log(
-                chalk.yellow('DEBUG: Error checking default API key:')
+                chalk.yellow('DEBUG: Error checking default API key:'),
               )
               console.log(chalk.yellow(String(error)))
             }
@@ -147,14 +160,14 @@ export function registerChatCommands(program: Command): void {
             const apiKeyService = ApiKeyService.getInstance()
             const keys = await apiKeyService.list()
             const selectedKey = keys.find(
-              (key) => key.id.toString() === options.apiKeyId
+              (key) => key.id.toString() === options.apiKeyId,
             )
 
             if (!selectedKey) {
               console.log(
                 chalk.yellow(
-                  `API key with ID ${options.apiKeyId} not found. Using default authentication.`
-                )
+                  `API key with ID ${options.apiKeyId} not found. Using default authentication.`,
+                ),
               )
             } else {
               console.log(chalk.dim(`Using API key: ${selectedKey.name}`))
@@ -163,37 +176,43 @@ export function registerChatCommands(program: Command): void {
               if (
                 await confirm(
                   chalk.yellow(
-                    `To use API key "${selectedKey.name}", it needs to be rotated. This will invalidate the current key. Continue? (y/n)`
-                  )
+                    `To use API key "${selectedKey.name}", it needs to be rotated. This will invalidate the current key. Continue? (y/n)`,
+                  ),
                 )
               ) {
                 const rotatedKey = await apiKeyService.rotate(options.apiKeyId)
                 apiKey = rotatedKey.key
                 console.log(
                   chalk.green(
-                    `API key "${selectedKey.name}" rotated successfully.`
-                  )
+                    `API key "${selectedKey.name}" rotated successfully.`,
+                  ),
                 )
               } else {
                 console.log(
-                  chalk.yellow('Using default authentication instead.')
+                  chalk.yellow('Using default authentication instead.'),
                 )
               }
             }
           } 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');
-            
+            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.'));
+              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.error(chalk.red('Error fetching API key:'))
+              console.error(error)
             }
-            console.log(chalk.yellow('Using default authentication instead.'));
+            console.log(chalk.yellow('Using default authentication instead.'))
           }
         }
 
@@ -207,23 +226,17 @@ export function registerChatCommands(program: Command): void {
             console.log(chalk.yellow('1. Log in with `berget auth login`'))
             console.log(chalk.yellow('2. Provide an API key with `--api-key`'))
             console.log(
-              chalk.yellow('3. Provide an API key ID with `--api-key-id`')
+              chalk.yellow('3. Provide an API key ID with `--api-key-id`'),
             )
             console.log(
               chalk.yellow(
-                '4. Set a default API key with `berget api-keys set-default <id>`'
-              )
+                '4. Set a default API key with `berget api-keys set-default <id>`',
+              ),
             )
             return
           }
         }
 
-        // Set up readline interface for user input
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout,
-        })
-
         // Prepare messages array
         const messages: ChatMessage[] = []
 
@@ -235,6 +248,151 @@ export function registerChatCommands(program: Command): void {
           })
         }
 
+        // Check if input is being piped in
+        let inputMessage = message
+        let stdinContent = ''
+
+        if (!process.stdin.isTTY) {
+          // Read from stdin (piped input)
+          const chunks = []
+          for await (const chunk of process.stdin) {
+            chunks.push(chunk)
+          }
+          stdinContent = Buffer.concat(chunks).toString('utf8').trim()
+        }
+
+        // Combine stdin content with message if both exist
+        if (stdinContent && message) {
+          inputMessage = `${stdinContent}\n\n${message}`
+        } else if (stdinContent && !message) {
+          inputMessage = stdinContent
+        }
+
+        // If a message is provided (either as argument, from stdin, or both), send it directly and exit
+        if (inputMessage) {
+          // Add user message
+          messages.push({
+            role: 'user',
+            content: inputMessage,
+          })
+
+          try {
+            // Call the API
+            const completionOptions: ChatCompletionOptions = {
+              model: model || 'openai/gpt-oss',
+              messages: messages,
+              temperature:
+                options.temperature !== undefined ? options.temperature : 0.7,
+              max_tokens: options.maxTokens || 4096,
+              stream: options.stream !== false,
+            }
+
+            // Only add apiKey if it actually exists
+            if (apiKey) {
+              completionOptions.apiKey = apiKey
+            }
+
+            // Add streaming support (now default)
+            if (completionOptions.stream) {
+              let assistantResponse = ''
+
+              // Stream the response in real-time
+              completionOptions.onChunk = (chunk: any) => {
+                if (
+                  chunk.choices &&
+                  chunk.choices[0] &&
+                  chunk.choices[0].delta &&
+                  chunk.choices[0].delta.content
+                ) {
+                  const content = chunk.choices[0].delta.content
+                  try {
+                    process.stdout.write(content)
+                  } catch (error: any) {
+                    // Handle EPIPE errors gracefully (when pipe is closed)
+                    if (error.code === 'EPIPE') {
+                      // Stop streaming if the pipe is closed
+                      return
+                    }
+                    throw error
+                  }
+                  assistantResponse += content
+                }
+              }
+
+              try {
+                await chatService.createCompletion(completionOptions)
+              } catch (streamError) {
+                console.error(chalk.red('\nStreaming error:'), streamError)
+
+                // Fallback to non-streaming if streaming fails
+                console.log(
+                  chalk.yellow('Falling back to non-streaming mode...'),
+                )
+                completionOptions.stream = false
+                delete completionOptions.onChunk
+
+                const response =
+                  await chatService.createCompletion(completionOptions)
+
+                if (
+                  response &&
+                  response.choices &&
+                  response.choices[0] &&
+                  response.choices[0].message
+                ) {
+                  assistantResponse = response.choices[0].message.content
+                  console.log(assistantResponse)
+                }
+              }
+              console.log() // Add newline at the end
+              return
+            }
+
+            const response =
+              await chatService.createCompletion(completionOptions)
+
+            // Check if response has the expected structure
+            if (
+              !response ||
+              !response.choices ||
+              !response.choices[0] ||
+              !response.choices[0].message
+            ) {
+              console.error(
+                chalk.red('Error: Unexpected response format from API'),
+              )
+              console.error(
+                chalk.red('Response:', JSON.stringify(response, null, 2)),
+              )
+              throw new Error('Unexpected response format from API')
+            }
+
+            // Get assistant's response
+            const assistantMessage = response.choices[0].message.content
+
+            // Display the response
+            if (containsMarkdown(assistantMessage)) {
+              console.log(renderMarkdown(assistantMessage))
+            } else {
+              console.log(assistantMessage)
+            }
+
+            return
+          } catch (error) {
+            console.error(chalk.red('Error: Failed to get response'))
+            if (error instanceof Error) {
+              console.error(chalk.red(error.message))
+            }
+            process.exit(1)
+          }
+        }
+
+        // Set up readline interface for user input (only for interactive mode)
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        })
+
         console.log(chalk.cyan('Chat with Berget AI (type "exit" to quit)'))
         console.log(chalk.cyan('----------------------------------------'))
 
@@ -257,51 +415,87 @@ export function registerChatCommands(program: Command): void {
             try {
               // Call the API
               const completionOptions: ChatCompletionOptions = {
-                model: options.args?.[0] || 'google/gemma-3-27b-it',
+                model: model || 'openai/gpt-oss',
                 messages: messages,
                 temperature:
                   options.temperature !== undefined ? options.temperature : 0.7,
                 max_tokens: options.maxTokens || 4096,
-                stream: options.stream || false
+                stream: options.stream !== false,
               }
 
               // Only add apiKey if it actually exists
               if (apiKey) {
                 completionOptions.apiKey = apiKey
               }
-              
-              // Add streaming support
-              if (options.stream) {
+
+              // Add streaming support (now default)
+              if (completionOptions.stream) {
                 let assistantResponse = ''
                 console.log(chalk.blue('Assistant: '))
-                
-                // For streaming, we'll collect the response and render it at the end
-                // since markdown needs the complete text to render properly
+
+                // Stream the response in real-time
                 completionOptions.onChunk = (chunk: any) => {
-                  if (chunk.choices && chunk.choices[0] && chunk.choices[0].delta && chunk.choices[0].delta.content) {
+                  if (
+                    chunk.choices &&
+                    chunk.choices[0] &&
+                    chunk.choices[0].delta &&
+                    chunk.choices[0].delta.content
+                  ) {
                     const content = chunk.choices[0].delta.content
-                    process.stdout.write(content)
+                    try {
+                      process.stdout.write(content)
+                    } catch (error: any) {
+                      // Handle EPIPE errors gracefully (when pipe is closed)
+                      if (error.code === 'EPIPE') {
+                        // Stop streaming if the pipe is closed
+                        return
+                      }
+                      throw error
+                    }
                     assistantResponse += content
                   }
                 }
-                
-                await chatService.createCompletion(completionOptions)
+
+                try {
+                  await chatService.createCompletion(completionOptions)
+                } catch (streamError) {
+                  console.error(chalk.red('\nStreaming error:'), streamError)
+
+                  // Fallback to non-streaming if streaming fails
+                  console.log(
+                    chalk.yellow('Falling back to non-streaming mode...'),
+                  )
+                  completionOptions.stream = false
+                  delete completionOptions.onChunk
+
+                  const response =
+                    await chatService.createCompletion(completionOptions)
+
+                  if (
+                    response &&
+                    response.choices &&
+                    response.choices[0] &&
+                    response.choices[0].message
+                  ) {
+                    assistantResponse = response.choices[0].message.content
+                    console.log(assistantResponse)
+                  }
+                }
                 console.log('\n')
-                
+
                 // Add assistant response to messages
                 messages.push({
                   role: 'assistant',
-                  content: assistantResponse
+                  content: assistantResponse,
                 })
-                
+
                 // Continue the conversation
                 askQuestion()
                 return
               }
-              
-              const response = await chatService.createCompletion(
-                completionOptions
-              )
+
+              const response =
+                await chatService.createCompletion(completionOptions)
 
               // Debug output
               if (program.opts().debug) {
@@ -317,10 +511,10 @@ export function registerChatCommands(program: Command): void {
                 !response.choices[0].message
               ) {
                 console.error(
-                  chalk.red('Error: Unexpected response format from API')
+                  chalk.red('Error: Unexpected response format from API'),
                 )
                 console.error(
-                  chalk.red('Response:', JSON.stringify(response, null, 2))
+                  chalk.red('Response:', JSON.stringify(response, null, 2)),
                 )
                 throw new Error('Unexpected response format from API')
               }
@@ -336,14 +530,14 @@ export function registerChatCommands(program: Command): void {
 
               // Display the response
               console.log(chalk.blue('Assistant: '))
-              
+
               // Check if the response contains markdown and render it if it does
               if (containsMarkdown(assistantMessage)) {
                 console.log(renderMarkdown(assistantMessage))
               } else {
                 console.log(assistantMessage)
               }
-              
+
               console.log() // Empty line for better readability
 
               // Continue the conversation
@@ -372,7 +566,7 @@ export function registerChatCommands(program: Command): void {
     .option('-k, --api-key <key>', 'API key to use for this request')
     .option(
       '--api-key-id <id>',
-      'ID of the API key to use from your saved keys'
+      'ID of the API key to use from your saved keys',
     )
     .action(async (options) => {
       try {
@@ -388,7 +582,7 @@ export function registerChatCommands(program: Command): void {
           if (defaultApiKeyData) {
             apiKeyId = defaultApiKeyData.id
             console.log(
-              chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
+              chalk.dim(`Using default API key: ${defaultApiKeyData.name}`),
             )
           }
         }
@@ -398,14 +592,14 @@ export function registerChatCommands(program: Command): void {
             const apiKeyService = ApiKeyService.getInstance()
             const keys = await apiKeyService.list()
             const selectedKey = keys.find(
-              (key) => key.id.toString() === options.apiKeyId
+              (key) => key.id.toString() === options.apiKeyId,
             )
 
             if (!selectedKey) {
               console.log(
                 chalk.yellow(
-                  `API key with ID ${options.apiKeyId} not found. Using default authentication.`
-                )
+                  `API key with ID ${options.apiKeyId} not found. Using default authentication.`,
+                ),
               )
             } else {
               console.log(chalk.dim(`Using API key: ${selectedKey.name}`))
@@ -414,20 +608,20 @@ export function registerChatCommands(program: Command): void {
               if (
                 await confirm(
                   chalk.yellow(
-                    `To use API key "${selectedKey.name}", it needs to be rotated. This will invalidate the current key. Continue? (y/n)`
-                  )
+                    `To use API key "${selectedKey.name}", it needs to be rotated. This will invalidate the current key. Continue? (y/n)`,
+                  ),
                 )
               ) {
                 const rotatedKey = await apiKeyService.rotate(options.apiKeyId)
                 apiKey = rotatedKey.key
                 console.log(
                   chalk.green(
-                    `API key "${selectedKey.name}" rotated successfully.`
-                  )
+                    `API key "${selectedKey.name}" rotated successfully.`,
+                  ),
                 )
               } else {
                 console.log(
-                  chalk.yellow('Using default authentication instead.')
+                  chalk.yellow('Using default authentication instead.'),
                 )
               }
             }
@@ -450,14 +644,15 @@ export function registerChatCommands(program: Command): void {
         console.log(chalk.bold('Available Chat Models:'))
         console.log(chalk.dim('─'.repeat(70)))
         console.log(
-          chalk.dim('MODEL ID'.padEnd(40)) +
-            chalk.dim('CAPABILITIES')
+          chalk.dim('MODEL ID'.padEnd(40)) + chalk.dim('CAPABILITIES'),
         )
         console.log(chalk.dim('─'.repeat(70)))
 
         // Filter to only show active models
-        const activeModels = models.data.filter((model: any) => model.active === true);
-        
+        const activeModels = models.data.filter(
+          (model: any) => model.active === true,
+        )
+
         activeModels.forEach((model: any) => {
           const capabilities = []
           if (model.capabilities.vision) capabilities.push('vision')
@@ -466,12 +661,11 @@ export function registerChatCommands(program: Command): void {
           if (model.capabilities.json_mode) capabilities.push('json_mode')
 
           // Format model ID in Huggingface compatible format (owner/model)
-          const modelId = `${model.owned_by.toLowerCase()}/${model.id}`.padEnd(40)
-          
-          console.log(
-            modelId +
-            capabilities.join(', ')
+          const modelId = `${model.owned_by.toLowerCase()}/${model.id}`.padEnd(
+            40,
           )
+
+          console.log(modelId + capabilities.join(', '))
         })
       } catch (error) {
         handleError('Failed to list chat models', error)

package/src/commands/clusters.ts

@@ -22,8 +22,8 @@ export function registerClusterCommands(program: Command): void {
         clusters.forEach((cluster: Cluster) => {
           console.log(
             `${cluster.name.padEnd(22)} ${cluster.status.padEnd(9)} ${String(
-              cluster.nodes
-            ).padEnd(8)} ${cluster.created}`
+              cluster.nodes,
+            ).padEnd(8)} ${cluster.created}`,
           )
         })
       } catch (error) {