@shareai-lab/kode 1.0.71 → 1.0.73

package/src/services/systemReminder.ts

@@ -82,28 +82,31 @@ class SystemReminderService {
       () => this.dispatchTodoEvent(agentId),
       () => this.dispatchSecurityEvent(),
       () => this.dispatchPerformanceEvent(),
+      () => this.getMentionReminders(), // Add mention reminders
     ]
 
     for (const generator of reminderGenerators) {
-      if (reminders.length >= 3) break // Limit concurrent reminders
-
-      const reminder = generator()
-      if (reminder) {
-        reminders.push(reminder)
-        this.sessionState.reminderCount++
+      if (reminders.length >= 5) break // Slightly increase limit to accommodate mentions
+
+      const result = generator()
+      if (result) {
+        // Handle both single reminders and arrays
+        const remindersToAdd = Array.isArray(result) ? result : [result]
+        reminders.push(...remindersToAdd)
+        this.sessionState.reminderCount += remindersToAdd.length
       }
     }
 
     // Log aggregated metrics instead of individual events for performance
     if (reminders.length > 0) {
       logEvent('system_reminder_batch', {
-        count: reminders.length,
+        count: reminders.length.toString(),
         types: reminders.map(r => r.type).join(','),
         priorities: reminders.map(r => r.priority).join(','),
         categories: reminders.map(r => r.category).join(','),
-        sessionCount: this.sessionState.reminderCount,
+        sessionCount: this.sessionState.reminderCount.toString(),
         agentId: agentId || 'default',
-        timestamp: currentTime,
+        timestamp: currentTime.toString(),
       })
     }
 
@@ -224,6 +227,43 @@ class SystemReminderService {
     return null
   }
 
+  /**
+   * Retrieve cached mention reminders
+   * Returns recent mentions (within 5 seconds) that haven't expired
+   */
+  private getMentionReminders(): ReminderMessage[] {
+    const currentTime = Date.now()
+    const MENTION_FRESHNESS_WINDOW = 5000 // 5 seconds
+    const reminders: ReminderMessage[] = []
+    const expiredKeys: string[] = []
+
+    // Single pass through cache for both collection and cleanup identification
+    for (const [key, reminder] of this.reminderCache.entries()) {
+      if (this.isMentionReminder(reminder)) {
+        const age = currentTime - reminder.timestamp
+        if (age <= MENTION_FRESHNESS_WINDOW) {
+          reminders.push(reminder)
+        } else {
+          expiredKeys.push(key)
+        }
+      }
+    }
+
+    // Clean up expired mention reminders in separate pass for performance
+    expiredKeys.forEach(key => this.reminderCache.delete(key))
+
+    return reminders
+  }
+
+  /**
+   * Type guard for mention reminders - centralized type checking
+   * Eliminates hardcoded type strings scattered throughout the code
+   */
+  private isMentionReminder(reminder: ReminderMessage): boolean {
+    const mentionTypes = ['agent_mention', 'file_mention', 'ask_model_mention']
+    return mentionTypes.includes(reminder.type)
+  }
+
   /**
    * Generate reminders for external file changes
    * Called when todo files are modified externally
@@ -302,9 +342,9 @@ class SystemReminderService {
       // Log session startup
       logEvent('system_reminder_session_startup', {
         agentId: context.agentId || 'default',
-        contextKeys: Object.keys(context.context || {}),
-        messageCount: context.messages || 0,
-        timestamp: context.timestamp,
+        contextKeys: Object.keys(context.context || {}).join(','),
+        messageCount: (context.messages || 0).toString(),
+        timestamp: context.timestamp.toString(),
       })
     })
 
@@ -343,6 +383,40 @@ class SystemReminderService {
     this.addEventListener('file:edited', context => {
       // File edit handling
     })
+
+    // Unified mention event handlers - eliminates code duplication
+    this.addEventListener('agent:mentioned', context => {
+      this.createMentionReminder({
+        type: 'agent_mention',
+        key: `agent_mention_${context.agentType}_${context.timestamp}`,
+        category: 'task',
+        priority: 'high',
+        content: `The user mentioned @${context.originalMention}. You MUST use the Task tool with subagent_type="${context.agentType}" to delegate this task to the specified agent. Provide a detailed, self-contained task description that fully captures the user's intent for the ${context.agentType} agent to execute.`,
+        timestamp: context.timestamp
+      })
+    })
+
+    this.addEventListener('file:mentioned', context => {
+      this.createMentionReminder({
+        type: 'file_mention',
+        key: `file_mention_${context.filePath}_${context.timestamp}`,
+        category: 'general',
+        priority: 'high',
+        content: `The user mentioned @${context.originalMention}. You MUST read the entire content of the file at path: ${context.filePath} using the Read tool to understand the full context before proceeding with the user's request.`,
+        timestamp: context.timestamp
+      })
+    })
+
+    this.addEventListener('ask-model:mentioned', context => {
+      this.createMentionReminder({
+        type: 'ask_model_mention',
+        key: `ask_model_mention_${context.modelName}_${context.timestamp}`,
+        category: 'task',
+        priority: 'high',
+        content: `The user mentioned @${context.modelName}. You MUST use the AskExpertModelTool to consult this specific model for expert opinions and analysis. Provide the user's question or context clearly to get the most relevant response from ${context.modelName}.`,
+        timestamp: context.timestamp
+      })
+    })
   }
 
   public addEventListener(
@@ -366,6 +440,33 @@ class SystemReminderService {
     })
   }
 
+  /**
+   * Unified mention reminder creation - eliminates duplicate logic
+   * Centralizes reminder creation with consistent deduplication
+   */
+  private createMentionReminder(params: {
+    type: string
+    key: string
+    category: ReminderMessage['category']
+    priority: ReminderMessage['priority']
+    content: string
+    timestamp: number
+  }): void {
+    if (!this.sessionState.remindersSent.has(params.key)) {
+      this.sessionState.remindersSent.add(params.key)
+      
+      const reminder = this.createReminderMessage(
+        params.type,
+        params.category,
+        params.priority,
+        params.content,
+        params.timestamp
+      )
+      
+      this.reminderCache.set(params.key, reminder)
+    }
+  }
+
   public resetSession(): void {
     this.sessionState = {
       lastTodoUpdate: 0,

package/src/test/testAdapters.ts

@@ -0,0 +1,96 @@
+import { ModelAdapterFactory } from '../services/modelAdapterFactory'
+import { getModelCapabilities } from '../constants/modelCapabilities'
+import { ModelProfile } from '../utils/config'
+
+// Test different models' adapter selection
+const testModels: ModelProfile[] = [
+  {
+    name: 'GPT-5 Test',
+    modelName: 'gpt-5',
+    provider: 'openai',
+    apiKey: 'test-key',
+    maxTokens: 8192,
+    contextLength: 128000,
+    reasoningEffort: 'medium',
+    isActive: true,
+    createdAt: Date.now()
+  },
+  {
+    name: 'GPT-4o Test',
+    modelName: 'gpt-4o',
+    provider: 'openai',
+    apiKey: 'test-key',
+    maxTokens: 4096,
+    contextLength: 128000,
+    isActive: true,
+    createdAt: Date.now()
+  },
+  {
+    name: 'Claude Test',
+    modelName: 'claude-3-5-sonnet-20241022',
+    provider: 'anthropic',
+    apiKey: 'test-key',
+    maxTokens: 4096,
+    contextLength: 200000,
+    isActive: true,
+    createdAt: Date.now()
+  },
+  {
+    name: 'O1 Test',
+    modelName: 'o1',
+    provider: 'openai',
+    apiKey: 'test-key',
+    maxTokens: 4096,
+    contextLength: 128000,
+    isActive: true,
+    createdAt: Date.now()
+  },
+  {
+    name: 'GLM-5 Test',
+    modelName: 'glm-5',
+    provider: 'custom',
+    apiKey: 'test-key',
+    maxTokens: 8192,
+    contextLength: 128000,
+    baseURL: 'https://api.glm.ai/v1',
+    isActive: true,
+    createdAt: Date.now()
+  }
+]
+
+console.log('🧪 Testing Model Adapter System\n')
+console.log('=' .repeat(60))
+
+testModels.forEach(model => {
+  console.log(`\n📊 Testing: ${model.name} (${model.modelName})`)
+  console.log('-'.repeat(40))
+  
+  // Get capabilities
+  const capabilities = getModelCapabilities(model.modelName)
+  console.log(`  ✓ API Architecture: ${capabilities.apiArchitecture.primary}`)
+  console.log(`  ✓ Fallback: ${capabilities.apiArchitecture.fallback || 'none'}`)
+  console.log(`  ✓ Max Tokens Field: ${capabilities.parameters.maxTokensField}`)
+  console.log(`  ✓ Tool Calling Mode: ${capabilities.toolCalling.mode}`)
+  console.log(`  ✓ Supports Freeform: ${capabilities.toolCalling.supportsFreeform}`)
+  console.log(`  ✓ Supports Streaming: ${capabilities.streaming.supported}`)
+  
+  // Test adapter creation
+  const adapter = ModelAdapterFactory.createAdapter(model)
+  console.log(`  ✓ Adapter Type: ${adapter.constructor.name}`)
+  
+  // Test shouldUseResponsesAPI
+  const shouldUseResponses = ModelAdapterFactory.shouldUseResponsesAPI(model)
+  console.log(`  ✓ Should Use Responses API: ${shouldUseResponses}`)
+  
+  // Test with custom endpoint
+  if (model.baseURL) {
+    const customModel = { ...model, baseURL: 'https://custom.api.com/v1' }
+    const customShouldUseResponses = ModelAdapterFactory.shouldUseResponsesAPI(customModel)
+    console.log(`  ✓ With Custom Endpoint: ${customShouldUseResponses ? 'Responses API' : 'Chat Completions'}`)
+  }
+})
+
+console.log('\n' + '='.repeat(60))
+console.log('✅ Adapter System Test Complete!')
+console.log('\nTo enable the new system, set USE_NEW_ADAPTERS=true')
+console.log('To use legacy system, set USE_NEW_ADAPTERS=false')

package/src/tools/AskExpertModelTool/AskExpertModelTool.tsx

@@ -22,7 +22,9 @@ import { debug as debugLogger } from '../../utils/debugLogger'
 import { applyMarkdown } from '../../utils/markdown'
 
 export const inputSchema = z.strictObject({
-  question: z.string().describe('The question to ask the expert model'),
+  question: z.string().describe(
+    'COMPLETE SELF-CONTAINED QUESTION: Must include full background context, relevant details, and a clear independent question. The expert model will receive ONLY this content with no access to previous conversation or external context. Structure as: 1) Background/Context 2) Specific situation/problem 3) Clear question. Ensure the expert can fully understand and respond without needing additional information.'
+  ),
   expert_model: z
     .string()
     .describe(
@@ -45,29 +47,40 @@ export type Out = {
 export const AskExpertModelTool = {
   name: 'AskExpertModel',
   async description() {
-    return 'Consults external AI models for specialized assistance and second opinions'
+    return "Consult external AI models for expert opinions and analysis"
   },
   async prompt() {
-    return `Consults external AI models for specialized assistance and second opinions. Maintains conversation history through persistent sessions.
-
-When to use AskExpertModel tool:
-- User explicitly requests a specific model ("use GPT-5 to...", "ask Claude about...", "consult Kimi for...")
-- User seeks second opinions or specialized model expertise  
-- User requests comparison between different model responses
-- Complex questions requiring specific model capabilities
-
-When NOT to use AskExpertModel tool:
-- General questions that don't specify a particular model
-- Tasks better suited for current model capabilities
-- Simple queries not requiring external expertise
-
-Usage notes:
-1. Use exact model names as specified by the user
-2. Sessions persist conversation context - use "new" for fresh conversations or provide existing session ID  
-3. External models operate independently without access to current project context
-4. Tool validates model availability and provides alternatives if model not found
-
-IMPORTANT: Always use the precise model name the user requested. The tool will handle model availability and provide guidance for unavailable models.`
+    return `Ask a question to a specific external AI model for expert analysis.
+
+This tool allows you to consult different AI models for their unique perspectives and expertise.
+
+CRITICAL REQUIREMENT FOR QUESTION PARAMETER:
+The question MUST be completely self-contained and include:
+1. FULL BACKGROUND CONTEXT - All relevant information the expert needs
+2. SPECIFIC SITUATION - Clear description of the current scenario/problem
+3. INDEPENDENT QUESTION - What exactly you want the expert to analyze/answer
+
+The expert model receives ONLY your question content with NO access to:
+- Previous conversation history (unless using existing session)  
+- Current codebase or file context
+- User's current task or project details
+
+IMPORTANT: This tool is for asking questions to models, not for task execution.
+- Use when you need a specific model's opinion or analysis
+- Use when you want to compare different models' responses
+- Use the @ask-[model] format when available
+
+The expert_model parameter accepts:
+- OpenAI: gpt-4, gpt-5, o1-preview
+- Anthropic: claude-3-5-sonnet, claude-3-opus  
+- Others: kimi, gemini-pro, mixtral
+
+Example of well-structured question:
+"Background: I'm working on a React TypeScript application with performance issues. The app renders a large list of 10,000 items using a simple map() function, causing UI freezing.
+
+Current situation: Users report 3-5 second delays when scrolling through the list. The component re-renders the entire list on every state change.
+
+Question: What are the most effective React optimization techniques for handling large lists, and how should I prioritize implementing virtualization vs memoization vs other approaches?"`
   },
   isReadOnly() {
     return true
@@ -89,11 +102,12 @@ IMPORTANT: Always use the precise model name the user requested. The tool will h
     question,
     expert_model,
     chat_session_id,
-  }): Promise<ValidationResult> {
+  }, context?: any): Promise<ValidationResult> {
     if (!question.trim()) {
       return { result: false, message: 'Question cannot be empty' }
     }
 
+
     if (!expert_model.trim()) {
       return { result: false, message: 'Expert model must be specified' }
     }
@@ -106,6 +120,35 @@ IMPORTANT: Always use the precise model name the user requested. The tool will h
       }
     }
 
+    // Check if trying to consult the same model we're currently running
+    try {
+      const modelManager = getModelManager()
+      
+      // Get current model based on context
+      let currentModel: string
+      if (context?.agentId && context?.options?.model) {
+        // In subagent context (Task tool)
+        currentModel = context.options.model
+      } else {
+        // In main agent context or after model switch
+        currentModel = modelManager.getModelName('main') || ''
+      }
+      
+      // Normalize model names for comparison
+      const normalizedExpert = expert_model.toLowerCase().replace(/[^a-z0-9]/g, '')
+      const normalizedCurrent = currentModel.toLowerCase().replace(/[^a-z0-9]/g, '')
+      
+      if (normalizedExpert === normalizedCurrent) {
+        return {
+          result: false,
+          message: `You are already running as ${currentModel}. Consulting the same model would be redundant. Please choose a different model or handle the task directly.`
+        }
+      }
+    } catch (e) {
+      // If we can't determine current model, allow the request
+      debugLogger('AskExpertModel', 'Could not determine current model:', e)
+    }
+
     // Validate that the model exists and is available
     try {
       const modelManager = getModelManager()
@@ -142,64 +185,72 @@ IMPORTANT: Always use the precise model name the user requested. The tool will h
   ) {
     if (!question || !expert_model) return null
     const isNewSession = chat_session_id === 'new'
-    const sessionDisplay = isNewSession ? 'new session' : chat_session_id
+    const sessionDisplay = isNewSession ? 'new session' : `session ${chat_session_id.substring(0, 5)}...`
+    const theme = getTheme()
 
     if (verbose) {
-      const theme = getTheme()
       return (
         <Box flexDirection="column">
-          <Text bold color={theme.text}>{expert_model}, {sessionDisplay}</Text>
-          <Box
-            borderStyle="single"
-            borderColor="green"
-            paddingX={1}
-            paddingY={0}
-            marginTop={1}
-          >
+          <Text bold color="yellow">{expert_model}</Text>
+          <Text color={theme.secondaryText}>{sessionDisplay}</Text>
+          <Box marginTop={1}>
             <Text color={theme.text}>
-              {applyMarkdown(question)}
+              {question.length > 300 ? question.substring(0, 300) + '...' : question}
             </Text>
           </Box>
         </Box>
       )
     }
-    return `${expert_model}, ${sessionDisplay}`
+    return (
+      <Box flexDirection="column">
+        <Text bold color="yellow">{expert_model} </Text>
+        <Text color={theme.secondaryText} dimColor>({sessionDisplay})</Text>
+      </Box>
+    )
   },
 
-  renderToolResultMessage(content, { verbose }) {
+  renderToolResultMessage(content) {
+    const verbose = true // Show more content
     const theme = getTheme()
 
     if (typeof content === 'object' && content && 'expertAnswer' in content) {
       const expertResult = content as Out
-      const isError = expertResult.expertAnswer.startsWith('❌')
+      const isError = expertResult.expertAnswer.startsWith('Error') || expertResult.expertAnswer.includes('failed')
       const isInterrupted = expertResult.chatSessionId === 'interrupted'
 
       if (isInterrupted) {
         return (
           <Box flexDirection="row">
-            <Text>&nbsp;&nbsp;⎿ &nbsp;</Text>
-            <Text color={theme.error}>[Expert consultation interrupted]</Text>
+            <Text color={theme.secondaryText}>Consultation interrupted</Text>
           </Box>
         )
       }
 
       const answerText = verbose 
         ? expertResult.expertAnswer.trim()
-        : expertResult.expertAnswer.length > 120
-          ? expertResult.expertAnswer.substring(0, 120) + '...'
+        : expertResult.expertAnswer.length > 500
+          ? expertResult.expertAnswer.substring(0, 500) + '...'
           : expertResult.expertAnswer.trim()
 
+      if (isError) {
+        return (
+          <Box flexDirection="column">
+            <Text color="red">{answerText}</Text>
+          </Box>
+        )
+      }
+
       return (
         <Box flexDirection="column">
-          <Box
-            borderStyle="single" 
-            borderColor="green" 
-            paddingX={1} 
-            paddingY={0}
-            marginTop={1}
-          >
-            <Text color={isError ? theme.error : theme.text}>
-              {isError ? answerText : applyMarkdown(answerText)}
+          <Text bold color={theme.text}>Response from {expertResult.expertModelName}:</Text>
+          <Box marginTop={1}>
+            <Text color={theme.text}>
+              {applyMarkdown(answerText)}
+            </Text>
+          </Box>
+          <Box marginTop={1}>
+            <Text color={theme.secondaryText} dimColor>
+              Session: {expertResult.chatSessionId.substring(0, 8)}
             </Text>
           </Box>
         </Box>
@@ -208,8 +259,7 @@ IMPORTANT: Always use the precise model name the user requested. The tool will h
 
     return (
       <Box flexDirection="row">
-        <Text>&nbsp;&nbsp;⎿ &nbsp;</Text>
-        <Text color={theme.secondaryText}>Expert consultation completed</Text>
+        <Text color={theme.secondaryText}>Consultation completed</Text>
       </Box>
     )
   },
@@ -314,6 +364,14 @@ ${output.expertAnswer}`
         return yield* this.handleInterrupt()
       }
 
+      // Yield progress message to show we're connecting
+      yield {
+        type: 'progress',
+        content: createAssistantMessage(
+          `Connecting to ${expertModel}... (timeout: 5 minutes)`
+        ),
+      }
+
       // Call model with comprehensive error handling and timeout
       let response
       try {
@@ -332,7 +390,7 @@ ${output.expertAnswer}`
         })
 
         // Create a timeout promise to prevent hanging
-        const timeoutMs = 60000 // 60 seconds timeout
+        const timeoutMs = 300000 // 300 seconds (5 minutes) timeout for external models
         const timeoutPromise = new Promise((_, reject) => {
           setTimeout(() => {
             reject(new Error(`Expert model query timed out after ${timeoutMs/1000}s`))
@@ -369,19 +427,25 @@ ${output.expertAnswer}`
 
         if (error.message?.includes('timed out')) {
           throw new Error(
-            `Expert model '${expertModel}' timed out. This often happens with slower APIs. Try again or use a different model.`,
+            `Expert model '${expertModel}' timed out after 5 minutes.\n\n` +
+            `Suggestions:\n` +
+            `  - The model might be experiencing high load\n` +
+            `  - Try a different model or retry later\n` +
+            `  - Consider breaking down your question into smaller parts`,
           )
         }
 
         if (error.message?.includes('rate limit')) {
           throw new Error(
-            'Rate limit exceeded for expert model. Please try again later.',
+            `Rate limit exceeded for ${expertModel}.\n\n` +
+            `Please wait a moment and try again, or use a different model.`,
           )
         }
 
         if (error.message?.includes('invalid api key')) {
           throw new Error(
-            'Invalid API key for expert model. Please check your configuration.',
+            `Invalid API key for ${expertModel}.\n\n` +
+            `Please check your model configuration with /model command.`,
           )
         }
 

package/src/tools/BashTool/BashTool.tsx

@@ -38,35 +38,8 @@ export type Out = {
 
 export const BashTool = {
   name: 'Bash',
-  async description({ command }) {
-    try {
-      const result = await queryQuick({
-        systemPrompt: [
-          `You are a command description generator. Write a clear, concise description of what this command does in 5-10 words. Examples:
-
-          Input: ls
-          Output: Lists files in current directory
-
-          Input: git status
-          Output: Shows working tree status
-
-          Input: npm install
-          Output: Installs package dependencies
-
-          Input: mkdir foo
-          Output: Creates directory 'foo'`,
-        ],
-        userPrompt: `Describe this command: ${command}`,
-      })
-      const description =
-        result.message.content[0]?.type === 'text'
-          ? result.message.content[0].text
-          : null
-      return description || 'Executes a bash command'
-    } catch (error) {
-      logError(error)
-      return 'Executes a bash command'
-    }
+  async description() {
+    return 'Executes shell commands on your computer'
   },
   async prompt() {
     const config = getGlobalConfig()
@@ -149,8 +122,8 @@ export const BashTool = {
     return <FallbackToolUseRejectedMessage />
   },
 
-  renderToolResultMessage(content, { verbose }) {
-    return <BashToolResultMessage content={content} verbose={verbose} />
+  renderToolResultMessage(content) {
+    return <BashToolResultMessage content={content} verbose={false} />
   },
   renderResultForAssistant({ interrupted, stdout, stderr }) {
     let errorMessage = stderr.trim()

package/src/tools/BashTool/BashToolResultMessage.tsx

@@ -9,7 +9,7 @@ type Props = {
   verbose: boolean
 }
 
-function BashToolResultMessage({ content, verbose }: Props): JSX.Element {
+function BashToolResultMessage({ content, verbose }: Props): React.JSX.Element {
   const { stdout, stdoutLines, stderr, stderrLines } = content
 
   return (

package/src/tools/BashTool/OutputLine.tsx

@@ -30,6 +30,7 @@ export function OutputLine({
   lines: number
   verbose: boolean
   isError?: boolean
+  key?: React.Key
 }) {
   return (
     <Box justifyContent="space-between" width="100%">

package/src/tools/FileEditTool/FileEditTool.tsx

@@ -47,10 +47,8 @@ export const FileEditTool = {
     return DESCRIPTION
   },
   inputSchema,
-  userFacingName({ old_string, new_string }) {
-    if (old_string === '') return 'Create'
-    if (new_string === '') return 'Delete'
-    return 'Update'
+  userFacingName() {
+    return 'Edit'
   },
   async isEnabled() {
     return true
@@ -67,7 +65,8 @@ export const FileEditTool = {
   renderToolUseMessage(input, { verbose }) {
     return `file_path: ${verbose ? input.file_path : relative(getCwd(), input.file_path)}`
   },
-  renderToolResultMessage({ filePath, structuredPatch }, { verbose }) {
+  renderToolResultMessage({ filePath, structuredPatch }) {
+    const verbose = false // Set default value for verbose
     return (
       <FileEditToolUpdatedMessage
         filePath={filePath}