@shareai-lab/kode 1.0.71 → 1.0.75

package/src/services/customCommands.ts

@@ -21,7 +21,7 @@ const execFileAsync = promisify(execFile)
  * @param content - The custom command content to process
  * @returns Promise<string> - Content with bash commands replaced by their output
  */
-async function executeBashCommands(content: string): Promise<string> {
+export async function executeBashCommands(content: string): Promise<string> {
   // Match patterns like !`git status` or !`command here`
   const bashCommandRegex = /!\`([^`]+)\`/g
   const matches = [...content.matchAll(bashCommandRegex)]
@@ -75,8 +75,10 @@ async function executeBashCommands(content: string): Promise<string> {
  * @param content - The custom command content to process
  * @returns Promise<string> - Content with file references replaced by file contents
  */
-async function resolveFileReferences(content: string): Promise<string> {
+export async function resolveFileReferences(content: string): Promise<string> {
   // Match patterns like @src/file.js or @path/to/file.txt
+  // Use consistent file mention pattern from mentionProcessor
+  // Exclude agent and ask-model patterns to avoid conflicts
   const fileRefRegex = /@([a-zA-Z0-9/._-]+(?:\.[a-zA-Z0-9]+)?)/g
   const matches = [...content.matchAll(fileRefRegex)]
 
@@ -90,6 +92,11 @@ async function resolveFileReferences(content: string): Promise<string> {
     const fullMatch = match[0]
     const filePath = match[1]
 
+    // Skip agent mentions - these are handled by the mention processor
+    if (filePath.startsWith('agent-')) {
+      continue
+    }
+
     try {
       // Resolve relative to current working directory
       // This maintains consistency with how other file operations work
@@ -169,7 +176,27 @@ export interface CustomCommandFrontmatter {
  * This extends the base Command interface to include scope metadata
  * for distinguishing between user-level and project-level commands.
  */
-export interface CustomCommandWithScope extends Command {
+export interface CustomCommandWithScope {
+  /** Command type - matches PromptCommand */
+  type: 'prompt'
+  /** Command name */
+  name: string
+  /** Command description */
+  description: string
+  /** Whether command is enabled */
+  isEnabled: boolean
+  /** Whether command is hidden */
+  isHidden: boolean
+  /** Command aliases */
+  aliases?: string[]
+  /** Progress message */
+  progressMessage: string
+  /** Argument names for legacy support */
+  argNames?: string[]
+  /** User-facing name function */
+  userFacingName(): string
+  /** Prompt generation function */
+  getPromptForCommand(args: string): Promise<MessageParam[]>
   /** Scope indicates whether this is a user or project command */
   scope?: 'user' | 'project'
 }
@@ -239,8 +266,7 @@ export function parseFrontmatter(content: string): {
     // End array processing when we hit a new key
     if (inArray && trimmed.includes(':')) {
       if (currentKey) {
-        frontmatter[currentKey as keyof CustomCommandFrontmatter] =
-          arrayItems as any
+        ;(frontmatter as any)[currentKey] = arrayItems
       }
       inArray = false
       arrayItems = []
@@ -260,7 +286,7 @@ export function parseFrontmatter(content: string): {
         .split(',')
         .map(s => s.trim().replace(/['"]/g, ''))
         .filter(s => s.length > 0)
-      frontmatter[key as keyof CustomCommandFrontmatter] = items as any
+      ;(frontmatter as any)[key] = items
     }
     // Handle multi-line arrays (value is empty or [])
     else if (value === '' || value === '[]') {
@@ -270,22 +296,17 @@ export function parseFrontmatter(content: string): {
     }
     // Handle boolean values
     else if (value === 'true' || value === 'false') {
-      frontmatter[key as keyof CustomCommandFrontmatter] = (value ===
-        'true') as any
+      ;(frontmatter as any)[key] = value === 'true'
     }
     // Handle string values (remove quotes)
     else {
-      frontmatter[key as keyof CustomCommandFrontmatter] = value.replace(
-        /['"]/g,
-        '',
-      ) as any
+      ;(frontmatter as any)[key] = value.replace(/['"]/g, '')
     }
   }
 
   // Handle final array if we ended in array mode
   if (inArray && currentKey) {
-    frontmatter[currentKey as keyof CustomCommandFrontmatter] =
-      arrayItems as any
+    ;(frontmatter as any)[currentKey] = arrayItems
   }
 
   return { frontmatter, content: markdownContent }
@@ -539,10 +560,10 @@ export const loadCustomCommands = memoize(
       // Log performance metrics for monitoring
       // This follows the same pattern as other performance-sensitive operations
       logEvent('tengu_custom_command_scan', {
-        durationMs: duration,
-        projectFilesFound: projectFiles.length,
-        userFilesFound: userFiles.length,
-        totalFiles: allFiles.length,
+        durationMs: duration.toString(),
+        projectFilesFound: projectFiles.length.toString(),
+        userFilesFound: userFiles.length.toString(),
+        totalFiles: allFiles.length.toString(),
       })
 
       // Parse files and create command objects
@@ -599,10 +620,10 @@ export const loadCustomCommands = memoize(
 
       // Log loading results for debugging and monitoring
       logEvent('tengu_custom_commands_loaded', {
-        totalCommands: commands.length,
-        enabledCommands: enabledCommands.length,
-        userCommands: commands.filter(cmd => cmd.scope === 'user').length,
-        projectCommands: commands.filter(cmd => cmd.scope === 'project').length,
+        totalCommands: commands.length.toString(),
+        enabledCommands: enabledCommands.length.toString(),
+        userCommands: commands.filter(cmd => cmd.scope === 'user').length.toString(),
+        projectCommands: commands.filter(cmd => cmd.scope === 'project').length.toString(),
       })
 
       return enabledCommands

package/src/services/gpt5ConnectionTest.ts

@@ -0,0 +1,340 @@
+/**
+ * 🔥 GPT-5 Connection Test Service
+ * 
+ * Specialized connection testing for GPT-5 models that supports both
+ * Responses API and Chat Completions API with proper fallback handling.
+ */
+
+import { getModelFeatures } from './openai'
+
+export interface ConnectionTestResult {
+  success: boolean
+  message: string
+  endpoint?: string
+  details?: string
+  apiUsed?: 'responses' | 'chat_completions'
+  responseTime?: number
+}
+
+export interface GPT5TestConfig {
+  model: string
+  apiKey: string
+  baseURL?: string
+  maxTokens?: number
+  provider?: string
+}
+
+/**
+ * Test GPT-5 model connection with intelligent API selection
+ */
+export async function testGPT5Connection(config: GPT5TestConfig): Promise<ConnectionTestResult> {
+  const startTime = Date.now()
+  
+  // Validate configuration
+  if (!config.model || !config.apiKey) {
+    return {
+      success: false,
+      message: 'Invalid configuration',
+      details: 'Model name and API key are required',
+    }
+  }
+
+  const isGPT5 = config.model.toLowerCase().includes('gpt-5')
+  const modelFeatures = getModelFeatures(config.model)
+  const baseURL = config.baseURL || 'https://api.openai.com/v1'
+  const isOfficialOpenAI = !config.baseURL || config.baseURL.includes('api.openai.com')
+
+  console.log(`🔧 Testing GPT-5 connection for model: ${config.model}`)
+  console.log(`🔧 Base URL: ${baseURL}`)
+  console.log(`🔧 Official OpenAI: ${isOfficialOpenAI}`)
+  console.log(`🔧 Supports Responses API: ${modelFeatures.supportsResponsesAPI}`)
+
+  // Try Responses API first for official GPT-5 models
+  if (isGPT5 && modelFeatures.supportsResponsesAPI && isOfficialOpenAI) {
+    console.log(`🚀 Attempting Responses API for ${config.model}`)
+    const responsesResult = await testResponsesAPI(config, baseURL, startTime)
+    
+    if (responsesResult.success) {
+      console.log(`✅ Responses API test successful for ${config.model}`)
+      return responsesResult
+    } else {
+      console.log(`⚠️ Responses API failed, falling back to Chat Completions: ${responsesResult.details}`)
+    }
+  }
+
+  // Fallback to Chat Completions API
+  console.log(`🔄 Using Chat Completions API for ${config.model}`)
+  return await testChatCompletionsAPI(config, baseURL, startTime)
+}
+
+/**
+ * Test using GPT-5 Responses API
+ */
+async function testResponsesAPI(
+  config: GPT5TestConfig, 
+  baseURL: string, 
+  startTime: number
+): Promise<ConnectionTestResult> {
+  const testURL = `${baseURL.replace(/\/+$/, '')}/responses`
+  
+  const testPayload = {
+    model: config.model,
+    input: [
+      {
+        role: 'user',
+        content: 'Please respond with exactly "YES" (in capital letters) to confirm this connection is working.',
+      },
+    ],
+    max_completion_tokens: Math.max(config.maxTokens || 8192, 8192),
+    temperature: 1, // GPT-5 requirement
+    reasoning: {
+      effort: 'low', // Fast response for connection test
+    },
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${config.apiKey}`,
+  }
+
+  console.log(`🔧 Responses API URL: ${testURL}`)
+  console.log(`🔧 Responses API payload:`, JSON.stringify(testPayload, null, 2))
+
+  try {
+    const response = await fetch(testURL, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(testPayload),
+    })
+
+    const responseTime = Date.now() - startTime
+
+    if (response.ok) {
+      const data = await response.json()
+      console.log(`✅ Responses API successful response:`, data)
+
+      // Extract content from Responses API format
+      let responseContent = ''
+      if (data.output_text) {
+        responseContent = data.output_text
+      } else if (data.output && Array.isArray(data.output)) {
+        // Extract from structured output format
+        const messageOutput = data.output.find(item => item.type === 'message')
+        if (messageOutput && messageOutput.content) {
+          const textContent = messageOutput.content.find(c => c.type === 'output_text')
+          responseContent = textContent?.text || ''
+        }
+      }
+
+      const containsYes = responseContent.toLowerCase().includes('yes')
+
+      if (containsYes) {
+        return {
+          success: true,
+          message: '✅ GPT-5 Responses API connection successful',
+          endpoint: '/responses',
+          details: `Model responded correctly: "${responseContent.trim()}"`,
+          apiUsed: 'responses',
+          responseTime,
+        }
+      } else {
+        return {
+          success: false,
+          message: '⚠️ Responses API connected but unexpected response',
+          endpoint: '/responses',
+          details: `Expected "YES" but got: "${responseContent.trim() || '(empty response)'}"`,
+          apiUsed: 'responses',
+          responseTime,
+        }
+      }
+    } else {
+      const errorData = await response.json().catch(() => null)
+      const errorMessage = errorData?.error?.message || errorData?.message || response.statusText
+
+      console.log(`❌ Responses API error (${response.status}):`, errorData)
+
+      return {
+        success: false,
+        message: `❌ Responses API failed (${response.status})`,
+        endpoint: '/responses',
+        details: `Error: ${errorMessage}`,
+        apiUsed: 'responses',
+        responseTime: Date.now() - startTime,
+      }
+    }
+  } catch (error) {
+    console.log(`❌ Responses API connection error:`, error)
+    
+    return {
+      success: false,
+      message: '❌ Responses API connection failed',
+      endpoint: '/responses',
+      details: error instanceof Error ? error.message : String(error),
+      apiUsed: 'responses',
+      responseTime: Date.now() - startTime,
+    }
+  }
+}
+
+/**
+ * Test using Chat Completions API with GPT-5 compatibility
+ */
+async function testChatCompletionsAPI(
+  config: GPT5TestConfig, 
+  baseURL: string, 
+  startTime: number
+): Promise<ConnectionTestResult> {
+  const testURL = `${baseURL.replace(/\/+$/, '')}/chat/completions`
+  
+  const isGPT5 = config.model.toLowerCase().includes('gpt-5')
+  
+  // Create test payload with GPT-5 compatibility
+  const testPayload: any = {
+    model: config.model,
+    messages: [
+      {
+        role: 'user',
+        content: 'Please respond with exactly "YES" (in capital letters) to confirm this connection is working.',
+      },
+    ],
+    temperature: isGPT5 ? 1 : 0, // GPT-5 requires temperature=1
+    stream: false,
+  }
+
+  // 🔧 Apply GPT-5 parameter transformations
+  if (isGPT5) {
+    testPayload.max_completion_tokens = Math.max(config.maxTokens || 8192, 8192)
+    delete testPayload.max_tokens  // 🔥 CRITICAL: Remove max_tokens for GPT-5
+    console.log(`🔧 GPT-5 mode: Using max_completion_tokens = ${testPayload.max_completion_tokens}`)
+  } else {
+    testPayload.max_tokens = Math.max(config.maxTokens || 8192, 8192)
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+  }
+
+  // Add provider-specific headers
+  if (config.provider === 'azure') {
+    headers['api-key'] = config.apiKey
+  } else {
+    headers['Authorization'] = `Bearer ${config.apiKey}`
+  }
+
+  console.log(`🔧 Chat Completions URL: ${testURL}`)
+  console.log(`🔧 Chat Completions payload:`, JSON.stringify(testPayload, null, 2))
+
+  try {
+    const response = await fetch(testURL, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(testPayload),
+    })
+
+    const responseTime = Date.now() - startTime
+
+    if (response.ok) {
+      const data = await response.json()
+      console.log(`✅ Chat Completions successful response:`, data)
+
+      const responseContent = data.choices?.[0]?.message?.content || ''
+      const containsYes = responseContent.toLowerCase().includes('yes')
+
+      if (containsYes) {
+        return {
+          success: true,
+          message: `✅ ${isGPT5 ? 'GPT-5' : 'Model'} Chat Completions connection successful`,
+          endpoint: '/chat/completions',
+          details: `Model responded correctly: "${responseContent.trim()}"`,
+          apiUsed: 'chat_completions',
+          responseTime,
+        }
+      } else {
+        return {
+          success: false,
+          message: '⚠️ Chat Completions connected but unexpected response',
+          endpoint: '/chat/completions',
+          details: `Expected "YES" but got: "${responseContent.trim() || '(empty response)'}"`,
+          apiUsed: 'chat_completions',
+          responseTime,
+        }
+      }
+    } else {
+      const errorData = await response.json().catch(() => null)
+      const errorMessage = errorData?.error?.message || errorData?.message || response.statusText
+
+      console.log(`❌ Chat Completions error (${response.status}):`, errorData)
+
+      // 🔧 Provide specific guidance for GPT-5 errors
+      let details = `Error: ${errorMessage}`
+      if (response.status === 400 && errorMessage.includes('max_tokens') && isGPT5) {
+        details += '\n\n🔧 GPT-5 Fix Applied: This error suggests a parameter compatibility issue. Please check if the provider supports GPT-5 with max_completion_tokens.'
+      }
+
+      return {
+        success: false,
+        message: `❌ Chat Completions failed (${response.status})`,
+        endpoint: '/chat/completions',
+        details: details,
+        apiUsed: 'chat_completions',
+        responseTime: Date.now() - startTime,
+      }
+    }
+  } catch (error) {
+    console.log(`❌ Chat Completions connection error:`, error)
+    
+    return {
+      success: false,
+      message: '❌ Chat Completions connection failed',
+      endpoint: '/chat/completions',
+      details: error instanceof Error ? error.message : String(error),
+      apiUsed: 'chat_completions',
+      responseTime: Date.now() - startTime,
+    }
+  }
+}
+
+/**
+ * Quick validation for GPT-5 configuration
+ */
+export function validateGPT5Config(config: GPT5TestConfig): { valid: boolean; errors: string[] } {
+  console.log(`🔧 validateGPT5Config called with:`, {
+    model: config.model,
+    hasApiKey: !!config.apiKey,
+    baseURL: config.baseURL,
+    provider: config.provider,
+  })
+  
+  const errors: string[] = []
+
+  if (!config.model) {
+    errors.push('Model name is required')
+  }
+
+  if (!config.apiKey) {
+    errors.push('API key is required')
+  }
+
+  if (config.apiKey && config.apiKey.length < 10) {
+    errors.push('API key appears to be invalid (too short)')
+  }
+
+  const isGPT5 = config.model?.toLowerCase().includes('gpt-5')
+  if (isGPT5) {
+    console.log(`🔧 GPT-5 validation: model=${config.model}, maxTokens=${config.maxTokens}`)
+    
+    if (config.maxTokens && config.maxTokens < 1000) {
+      errors.push('GPT-5 models typically require at least 1000 max tokens')
+    }
+    
+    // 完全移除第三方provider限制，允许所有代理中转站使用GPT-5
+    console.log(`🔧 No third-party restrictions applied for GPT-5`)
+  }
+
+  console.log(`🔧 Validation result:`, { valid: errors.length === 0, errors })
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  }
+}

package/src/services/mcpClient.ts

@@ -331,7 +331,7 @@ export const getClients = memoize(async (): Promise<WrappedClient[]> => {
   return await Promise.all(
     Object.entries(allServers).map(async ([name, serverRef]) => {
       try {
-        const client = await connectToServer(name, serverRef)
+        const client = await connectToServer(name, serverRef as McpServerConfig)
         logEvent('tengu_mcp_server_connection_succeeded', {})
         return { name, client, type: 'connected' as const }
       } catch (error) {