berget 2.0.6 → 2.1.1

package/src/services/auth-service.ts

@@ -36,13 +36,10 @@ export class AuthService {
     try {
       const { data: profile, error } = await this.client.GET('/v1/users/me')
       if (error) {
-        throw new Error(
-          error ? JSON.stringify(error) : 'Failed to get user profile',
-        )
+        return null
       }
       return profile
     } catch (error) {
-      handleError('Failed to get user profile', error)
       return null
     }
   }

package/src/services/chat-service.ts

@@ -386,6 +386,7 @@ export class ChatService {
       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()
@@ -394,17 +395,76 @@ export class ChatService {
         const chunk = decoder.decode(value, { stream: true })
         logger.debug(`Received chunk: ${chunk.length} bytes`)
 
-        // Process the chunk - it may contain multiple SSE events
-        const lines = chunk.split('\n')
-        for (const line of lines) {
+        // Add chunk to buffer
+        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`)
+        
+        // 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}"`)
+          
           if (line.startsWith('data:')) {
             const jsonData = line.slice(5).trim()
+            logger.debug(`Extracted JSON data: "${jsonData}"`)
 
             // Skip empty data or [DONE] marker
-            if (jsonData === '' || jsonData === '[DONE]') continue
+            if (jsonData === '' || jsonData === '[DONE]') {
+              logger.debug(`Skipping empty data or [DONE] marker`)
+              processedLines = i + 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)}..."`)
+              // Don't process this line yet, keep it in buffer
+              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]
+              if (escaped) {
+                escaped = false
+                continue
+              }
+              if (char === '\\') {
+                escaped = true
+                continue
+              }
+              if (char === '"') {
+                inString = !inString
+                continue
+              }
+              if (!inString && char === '{') {
+                braceCount++
+              } else if (!inString && char === '}') {
+                braceCount--
+              }
+            }
+            
+            if (braceCount !== 0) {
+              logger.warn(`JSON braces don't balance (${braceCount}), treating as partial: "${jsonData.substring(0, 50)}..."`)
+              // Don't process this line yet, keep it in buffer
+              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
 
               // Call the onChunk callback with the parsed data
               if (options.onChunk) {
@@ -426,10 +486,31 @@ export class ChatService {
               }
             } catch (e) {
               logger.error(`Error parsing chunk: ${e}`)
-              logger.debug(`Problematic chunk: ${jsonData}`)
+              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)}"`)
+              
+              // Show character codes around the error position
+              const errorPos = parseInt((e 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(' ')}`)
+              }
             }
           }
         }
+        
+        // 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}`)
+        }
       }
 
       // Construct the final response object similar to non-streaming response

package/src/utils/config-loader.ts

@@ -33,6 +33,10 @@ export interface ProviderModelConfig {
     output: number
     context: number
   }
+  modalities?: {
+    input: string[]
+    output: string[]
+  }
 }
 
 export interface OpenCodeConfig {
@@ -66,6 +70,13 @@ export class ConfigLoader {
     return ConfigLoader.instance
   }
 
+  /**
+   * Clear the singleton instance (for testing purposes)
+   */
+  public static clearInstance(): void {
+    ConfigLoader.instance = null as any
+  }
+
   /**
    * Load configuration from opencode.json
    */
@@ -81,12 +92,19 @@ export class ConfigLoader {
 
       const configContent = fs.readFileSync(this.configPath, 'utf8')
       this.config = JSON.parse(configContent) as OpenCodeConfig
-      
+
       logger.debug(`Loaded configuration from ${this.configPath}`)
       return this.config
     } catch (error) {
-      logger.error(`Failed to load configuration from ${this.configPath}:`, error)
-      throw new Error(`Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`)
+      logger.error(
+        `Failed to load configuration from ${this.configPath}:`,
+        error
+      )
+      throw new Error(
+        `Failed to load configuration: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      )
     }
   }
 
@@ -94,56 +112,85 @@ export class ConfigLoader {
    * Get agent configuration by name
    */
   public getAgentConfig(agentName: string): AgentConfig | null {
-    const config = this.loadConfig()
-    return config.agent?.[agentName] || null
+    try {
+      const config = this.loadConfig()
+      return config.agent?.[agentName] || null
+    } catch (error) {
+      // Config file doesn't exist, return null
+      return null
+    }
   }
 
   /**
    * Get all agent configurations
    */
   public getAllAgentConfigs(): Record<string, AgentConfig> {
-    const config = this.loadConfig()
-    return config.agent || {}
+    try {
+      const config = this.loadConfig()
+      return config.agent || {}
+    } catch (error) {
+      // Config file doesn't exist, return empty object
+      return {}
+    }
   }
 
   /**
    * Get model configuration
    */
   public getModelConfig(): ModelConfig {
-    const config = this.loadConfig()
-    
-    // Extract from config or fall back to defaults
-    const primary = config.model || 'berget/deepseek-r1'
-    const small = config.small_model || 'berget/gpt-oss'
-    
-    return { primary, small }
+    try {
+      const config = this.loadConfig()
+
+      // Extract from config or fall back to defaults
+      const primary = config.model || 'berget/glm-4.7'
+      const small = config.small_model || 'berget/gpt-oss'
+
+      return { primary, small }
+    } catch (error) {
+      // Fallback to defaults when no config exists (init scenario)
+      return {
+        primary: 'berget/glm-4.7',
+        small: 'berget/gpt-oss',
+      }
+    }
   }
 
   /**
    * Get provider model configuration
    */
   public getProviderModels(): Record<string, ProviderModelConfig> {
-    const config = this.loadConfig()
-    
-    // Extract from provider configuration
-    if (config.provider?.berget?.models) {
-      return config.provider.berget.models as Record<string, ProviderModelConfig>
+    try {
+      const config = this.loadConfig()
+
+      // Extract from provider configuration
+      if (config.provider?.berget?.models) {
+        return config.provider.berget.models as Record<
+          string,
+          ProviderModelConfig
+        >
+      }
+    } catch (error) {
+      // Config file doesn't exist, use fallback defaults
     }
-    
+
     // Fallback to defaults
     return {
-      'deepseek-r1': {
-        name: 'GLM-4.6',
-        limit: { output: 4000, context: 90000 }
+      'glm-4.7': {
+        name: 'GLM-4.7',
+        limit: { output: 4000, context: 90000 },
       },
       'gpt-oss': {
         name: 'GPT-OSS',
-        limit: { output: 4000, context: 128000 }
+        limit: { output: 4000, context: 128000 },
+        modalities: {
+          input: ['text', 'image'],
+          output: ['text'],
+        },
       },
       'llama-8b': {
         name: 'llama-3.1-8b',
-        limit: { output: 4000, context: 128000 }
-      }
+        limit: { output: 4000, context: 128000 },
+      },
     }
   }
 
@@ -151,24 +198,43 @@ export class ConfigLoader {
    * Get command configurations
    */
   public getCommandConfigs(): Record<string, any> {
-    const config = this.loadConfig()
-    return config.command || {}
+    try {
+      const config = this.loadConfig()
+      return config.command || {}
+    } catch (error) {
+      // Config file doesn't exist, return empty object
+      return {}
+    }
   }
 
   /**
    * Get watcher configuration
    */
   public getWatcherConfig(): Record<string, any> {
-    const config = this.loadConfig()
-    return config.watcher || { ignore: ['node_modules', 'dist', '.git', 'coverage'] }
+    try {
+      const config = this.loadConfig()
+      return (
+        config.watcher || {
+          ignore: ['node_modules', 'dist', '.git', 'coverage'],
+        }
+      )
+    } catch (error) {
+      // Config file doesn't exist, return default watcher config
+      return { ignore: ['node_modules', 'dist', '.git', 'coverage'] }
+    }
   }
 
   /**
    * Get provider configuration
    */
   public getProviderConfig(): Record<string, any> {
-    const config = this.loadConfig()
-    return config.provider || {}
+    try {
+      const config = this.loadConfig()
+      return config.provider || {}
+    } catch (error) {
+      // Config file doesn't exist, return empty object
+      return {}
+    }
   }
 
   /**
@@ -190,7 +256,7 @@ export class ConfigLoader {
    */
   public getPrimaryAgentNames(): string[] {
     const agents = this.getAllAgentConfigs()
-    return Object.keys(agents).filter(name => agents[name].mode === 'primary')
+    return Object.keys(agents).filter((name) => agents[name].mode === 'primary')
   }
 
   /**
@@ -198,7 +264,9 @@ export class ConfigLoader {
    */
   public getSubagentNames(): string[] {
     const agents = this.getAllAgentConfigs()
-    return Object.keys(agents).filter(name => agents[name].mode === 'subagent')
+    return Object.keys(agents).filter(
+      (name) => agents[name].mode === 'subagent'
+    )
   }
 
   /**
@@ -235,14 +303,19 @@ export function getConfigLoader(configPath?: string): ConfigLoader {
 /**
  * Convenience function to get agent configuration
  */
-export function getAgentConfig(agentName: string, configPath?: string): AgentConfig | null {
+export function getAgentConfig(
+  agentName: string,
+  configPath?: string
+): AgentConfig | null {
   return getConfigLoader(configPath).getAgentConfig(agentName)
 }
 
 /**
  * Convenience function to get all agent configurations
  */
-export function getAllAgentConfigs(configPath?: string): Record<string, AgentConfig> {
+export function getAllAgentConfigs(
+  configPath?: string
+): Record<string, AgentConfig> {
   return getConfigLoader(configPath).getAllAgentConfigs()
 }
 
@@ -256,6 +329,8 @@ export function getModelConfig(configPath?: string): ModelConfig {
 /**
  * Convenience function to get provider models
  */
-export function getProviderModels(configPath?: string): Record<string, ProviderModelConfig> {
+export function getProviderModels(
+  configPath?: string
+): Record<string, ProviderModelConfig> {
   return getConfigLoader(configPath).getProviderModels()
-}
+}

package/tests/commands/chat.test.ts

@@ -46,7 +46,7 @@ describe('Chat Commands', () => {
   })
 
   describe('chat run command', () => {
-    it('should use openai/gpt-oss as default model', () => {
+    it('should use berget/glm-4.7 as default model', () => {
       const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat')
       const runCommand = chatCommand?.commands.find(
         (cmd) => cmd.name() === 'run',
@@ -56,7 +56,7 @@ describe('Chat Commands', () => {
 
       // Check the help text which contains the default model
       const helpText = runCommand?.helpInformation()
-      expect(helpText).toContain('openai/gpt-oss')
+      expect(helpText).toContain('glm-4.7')
     })
 
     it('should have streaming enabled by default', () => {

package/tests/commands/code.test.ts

@@ -194,7 +194,7 @@ describe('Code Commands', () => {
     it('should create opencode.json with correct structure', async () => {
       // This tests the expected config structure
       const expectedConfig = {
-        model: 'berget/deepseek-r1',
+        model: 'berget/glm-4-6',
         apiKey: 'test-api-key',
         projectName: 'testproject',
         provider: 'berget',
@@ -202,7 +202,7 @@ describe('Code Commands', () => {
         version: '1.0.0',
       }
 
-      expect(expectedConfig.model).toBe('berget/deepseek-r1')
+      expect(expectedConfig.model).toBe('berget/glm-4-6')
       expect(expectedConfig.provider).toBe('berget')
       expect(expectedConfig.version).toBe('1.0.0')
     })
@@ -259,7 +259,7 @@ describe('Code Commands', () => {
 
     it('should load configuration from opencode.json', async () => {
       const mockConfig = {
-        model: 'berget/deepseek-r1',
+        model: 'berget/glm-4-6',
         apiKey: 'test-api-key',
         projectName: 'testproject',
         provider: 'berget',
@@ -284,7 +284,7 @@ describe('Code Commands', () => {
       })
 
       // Verify config structure expectations
-      expect(mockConfig.model).toBe('berget/deepseek-r1')
+      expect(mockConfig.model).toBe('berget/glm-4-6')
       expect(mockConfig.apiKey).toBe('test-api-key')
       expect(mockConfig.projectName).toBe('testproject')
     })