@shareai-lab/kode 1.0.71 → 1.0.75

package/src/messages.ts

@@ -1,3 +1,4 @@
+import React from 'react'
 import type { Message } from './query'
 
 let getMessages: () => Message[] = () => []

package/src/query.ts

@@ -80,6 +80,7 @@ export type AssistantMessage = {
   type: 'assistant'
   uuid: UUID
   isApiErrorMessage?: boolean
+  responseId?: string // For GPT-5 Responses API state management
 }
 
 export type BinaryFeedbackResult =
@@ -230,6 +231,7 @@ export async function* query(
         safeMode: toolUseContext.options.safeMode ?? false,
         model: toolUseContext.options.model || 'main',
         prependCLISysprompt: true,
+        toolUseContext: toolUseContext,
       },
     )
   }
@@ -408,6 +410,7 @@ export async function* runToolUse(
     currentRequest?.id,
   )
 
+
   logEvent('tengu_tool_use_start', {
     toolName: toolUse.name,
     toolUseID: toolUse.id,

package/src/screens/ConfigureNpmPrefix.tsx

@@ -1,6 +1,6 @@
 import React, { useState } from 'react'
 import { Box, Text } from 'ink'
-import { Select } from '@inkjs/ui'
+import { Select } from '../components/CustomSelect/select'
 import TextInput from '../components/TextInput'
 import { SimpleSpinner } from '../components/Spinner'
 import { getTheme } from '../utils/theme'

package/src/screens/Doctor.tsx

@@ -1,6 +1,6 @@
 import React, { useCallback, useEffect, useState } from 'react'
 import { Box, Text, useInput } from 'ink'
-import { Select } from '@inkjs/ui'
+import { Select } from '../components/CustomSelect/select'
 import { getTheme } from '../utils/theme'
 import { ConfigureNpmPrefix } from './ConfigureNpmPrefix.tsx'
 import { platform } from 'process'

package/src/screens/REPL.tsx

@@ -171,17 +171,15 @@ export function REPL({
   }>({})
 
   const { status: apiKeyStatus, reverify } = useApiKeyVerification()
-  // 🔧 FIXED: Simple cancellation logic matching original claude-code
   function onCancel() {
     if (!isLoading) {
       return
     }
     setIsLoading(false)
     if (toolUseConfirm) {
-      // Tool use confirm handles the abort signal itself
       toolUseConfirm.onAbort()
-    } else {
-      abortController?.abort()
+    } else if (abortController && !abortController.signal.aborted) {
+      abortController.abort()
     }
   }
 
@@ -392,7 +390,7 @@ export function REPL({
     }
 
     // If this was a Koding request and we got an assistant message back,
-    // save it to KODE.md (and CLAUDE.md if exists)
+    // save it to AGENTS.md (and CLAUDE.md if exists)
     if (
       isKodingRequest &&
       lastAssistantMessage &&
@@ -407,7 +405,7 @@ export function REPL({
                 .map(block => (block.type === 'text' ? block.text : ''))
                 .join('\n')
 
-        // Add the content to KODE.md (and CLAUDE.md if exists)
+        // Add the content to AGENTS.md (and CLAUDE.md if exists)
         if (content && content.trim().length > 0) {
           handleHashCommand(content)
         }
@@ -605,12 +603,13 @@ export function REPL({
   return (
     <PermissionProvider isBypassPermissionsModeAvailable={!safeMode}>
       <ModeIndicator />
-      <Static
-        key={`static-messages-${forkNumber}`}
-        items={messagesJSX.filter(_ => _.type === 'static')}
-      >
-        {_ => _.jsx}
-      </Static>
+      <React.Fragment key={`static-messages-${forkNumber}`}>
+        <Static
+          items={messagesJSX.filter(_ => _.type === 'static')}
+        >
+          {_ => _.jsx}
+        </Static>
+      </React.Fragment>
       {messagesJSX.filter(_ => _.type === 'transient').map(_ => _.jsx)}
       <Box
         borderColor="red"

package/src/services/adapters/base.ts

@@ -0,0 +1,38 @@
+import { ModelCapabilities, UnifiedRequestParams, UnifiedResponse } from '../../types/modelCapabilities'
+import { ModelProfile } from '../../utils/config'
+import { Tool } from '../../Tool'
+
+export abstract class ModelAPIAdapter {
+  constructor(
+    protected capabilities: ModelCapabilities,
+    protected modelProfile: ModelProfile
+  ) {}
+  
+  // Subclasses must implement these methods
+  abstract createRequest(params: UnifiedRequestParams): any
+  abstract parseResponse(response: any): UnifiedResponse
+  abstract buildTools(tools: Tool[]): any
+  
+  // Shared utility methods
+  protected getMaxTokensParam(): string {
+    return this.capabilities.parameters.maxTokensField
+  }
+  
+  protected getTemperature(): number {
+    if (this.capabilities.parameters.temperatureMode === 'fixed_one') {
+      return 1
+    }
+    if (this.capabilities.parameters.temperatureMode === 'restricted') {
+      return Math.min(1, 0.7)
+    }
+    return 0.7
+  }
+  
+  protected shouldIncludeReasoningEffort(): boolean {
+    return this.capabilities.parameters.supportsReasoningEffort
+  }
+  
+  protected shouldIncludeVerbosity(): boolean {
+    return this.capabilities.parameters.supportsVerbosity
+  }
+}

package/src/services/adapters/chatCompletions.ts

@@ -0,0 +1,90 @@
+import { ModelAPIAdapter } from './base'
+import { UnifiedRequestParams, UnifiedResponse } from '../../types/modelCapabilities'
+import { Tool } from '../../Tool'
+import { zodToJsonSchema } from 'zod-to-json-schema'
+
+export class ChatCompletionsAdapter extends ModelAPIAdapter {
+  createRequest(params: UnifiedRequestParams): any {
+    const { messages, systemPrompt, tools, maxTokens, stream } = params
+    
+    // Build complete message list (including system prompts)
+    const fullMessages = this.buildMessages(systemPrompt, messages)
+    
+    // Build request
+    const request: any = {
+      model: this.modelProfile.modelName,
+      messages: fullMessages,
+      [this.getMaxTokensParam()]: maxTokens,
+      temperature: this.getTemperature()
+    }
+    
+    // Add tools
+    if (tools && tools.length > 0) {
+      request.tools = this.buildTools(tools)
+      request.tool_choice = 'auto'
+    }
+    
+    // Add reasoning effort for GPT-5 via Chat Completions
+    if (this.shouldIncludeReasoningEffort() && params.reasoningEffort) {
+      request.reasoning_effort = params.reasoningEffort  // Chat Completions format
+    }
+    
+    // Add verbosity for GPT-5 via Chat Completions
+    if (this.shouldIncludeVerbosity() && params.verbosity) {
+      request.verbosity = params.verbosity  // Chat Completions format
+    }
+    
+    // Add streaming options
+    if (stream) {
+      request.stream = true
+      request.stream_options = {
+        include_usage: true
+      }
+    }
+    
+    // O1 model special handling
+    if (this.modelProfile.modelName.startsWith('o1')) {
+      delete request.temperature  // O1 doesn't support temperature
+      delete request.stream  // O1 doesn't support streaming
+      delete request.stream_options
+    }
+    
+    return request
+  }
+  
+  buildTools(tools: Tool[]): any[] {
+    // Chat Completions only supports traditional function calling
+    return tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description || '',
+        parameters: tool.inputJSONSchema || zodToJsonSchema(tool.inputSchema)
+      }
+    }))
+  }
+  
+  parseResponse(response: any): UnifiedResponse {
+    const choice = response.choices?.[0]
+    
+    return {
+      id: response.id || `chatcmpl_${Date.now()}`,
+      content: choice?.message?.content || '',
+      toolCalls: choice?.message?.tool_calls || [],
+      usage: {
+        promptTokens: response.usage?.prompt_tokens || 0,
+        completionTokens: response.usage?.completion_tokens || 0
+      }
+    }
+  }
+  
+  private buildMessages(systemPrompt: string[], messages: any[]): any[] {
+    // Merge system prompts and messages
+    const systemMessages = systemPrompt.map(prompt => ({
+      role: 'system',
+      content: prompt
+    }))
+    
+    return [...systemMessages, ...messages]
+  }
+}

package/src/services/adapters/responsesAPI.ts

@@ -0,0 +1,170 @@
+import { ModelAPIAdapter } from './base'
+import { UnifiedRequestParams, UnifiedResponse } from '../../types/modelCapabilities'
+import { Tool } from '../../Tool'
+import { zodToJsonSchema } from 'zod-to-json-schema'
+
+export class ResponsesAPIAdapter extends ModelAPIAdapter {
+  createRequest(params: UnifiedRequestParams): any {
+    const { messages, systemPrompt, tools, maxTokens } = params
+    
+    // Separate system messages and user messages
+    const systemMessages = messages.filter(m => m.role === 'system')
+    const nonSystemMessages = messages.filter(m => m.role !== 'system')
+    
+    // Build base request
+    const request: any = {
+      model: this.modelProfile.modelName,
+      input: this.convertMessagesToInput(nonSystemMessages),
+      instructions: this.buildInstructions(systemPrompt, systemMessages)
+    }
+    
+    // Add token limit
+    request[this.getMaxTokensParam()] = maxTokens
+    
+    // Add temperature (GPT-5 only supports 1)
+    if (this.getTemperature() === 1) {
+      request.temperature = 1
+    }
+    
+    // Add reasoning control - correct format for Responses API
+    if (this.shouldIncludeReasoningEffort()) {
+      request.reasoning = {
+        effort: params.reasoningEffort || this.modelProfile.reasoningEffort || 'medium'
+      }
+    }
+    
+    // Add verbosity control - correct format for Responses API
+    if (this.shouldIncludeVerbosity()) {
+      request.text = {
+        verbosity: params.verbosity || 'high'  // High verbosity for coding tasks
+      }
+    }
+    
+    // Add tools
+    if (tools && tools.length > 0) {
+      request.tools = this.buildTools(tools)
+      
+      // Handle allowed_tools
+      if (params.allowedTools && this.capabilities.toolCalling.supportsAllowedTools) {
+        request.tool_choice = {
+          type: 'allowed_tools',
+          mode: 'auto',
+          tools: params.allowedTools
+        }
+      }
+    }
+    
+    // Add state management
+    if (params.previousResponseId && this.capabilities.stateManagement.supportsPreviousResponseId) {
+      request.previous_response_id = params.previousResponseId
+    }
+    
+    return request
+  }
+  
+  buildTools(tools: Tool[]): any[] {
+    // If freeform not supported, use traditional format
+    if (!this.capabilities.toolCalling.supportsFreeform) {
+      return tools.map(tool => ({
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description || '',
+          parameters: tool.inputJSONSchema || zodToJsonSchema(tool.inputSchema)
+        }
+      }))
+    }
+    
+    // Custom tools format (GPT-5 feature)
+    return tools.map(tool => {
+      const hasSchema = tool.inputJSONSchema || tool.inputSchema
+      const isCustom = !hasSchema
+      
+      if (isCustom) {
+        // Custom tool format
+        return {
+          type: 'custom',
+          name: tool.name,
+          description: tool.description || ''
+        }
+      } else {
+        // Traditional function format
+        return {
+          type: 'function',
+          function: {
+            name: tool.name,
+            description: tool.description || '',
+            parameters: tool.inputJSONSchema || zodToJsonSchema(tool.inputSchema)
+          }
+        }
+      }
+    })
+  }
+  
+  parseResponse(response: any): UnifiedResponse {
+    // Process basic text output
+    let content = response.output_text || ''
+    
+    // Process structured output
+    if (response.output && Array.isArray(response.output)) {
+      const messageItems = response.output.filter(item => item.type === 'message')
+      if (messageItems.length > 0) {
+        content = messageItems
+          .map(item => {
+            if (item.content && Array.isArray(item.content)) {
+              return item.content
+                .filter(c => c.type === 'text')
+                .map(c => c.text)
+                .join('\n')
+            }
+            return item.content || ''
+          })
+          .filter(Boolean)
+          .join('\n\n')
+      }
+    }
+    
+    // Parse tool calls
+    const toolCalls = this.parseToolCalls(response)
+    
+    // Build unified response
+    return {
+      id: response.id || `resp_${Date.now()}`,
+      content,
+      toolCalls,
+      usage: {
+        promptTokens: response.usage?.input_tokens || 0,
+        completionTokens: response.usage?.output_tokens || 0,
+        reasoningTokens: response.usage?.output_tokens_details?.reasoning_tokens
+      },
+      responseId: response.id  // Save for state management
+    }
+  }
+  
+  private convertMessagesToInput(messages: any[]): any {
+    // Convert messages to Responses API input format
+    // May need adjustment based on actual API specification
+    return messages
+  }
+  
+  private buildInstructions(systemPrompt: string[], systemMessages: any[]): string {
+    const systemContent = systemMessages.map(m => m.content).join('\n\n')
+    const promptContent = systemPrompt.join('\n\n')
+    return [systemContent, promptContent].filter(Boolean).join('\n\n')
+  }
+  
+  private parseToolCalls(response: any): any[] {
+    if (!response.output || !Array.isArray(response.output)) {
+      return []
+    }
+    
+    return response.output
+      .filter(item => item.type === 'tool_call')
+      .map(item => ({
+        id: item.id || `tool_${Date.now()}`,
+        type: 'tool_call',
+        name: item.name,
+        arguments: item.arguments  // Can be text or JSON
+      }))
+  }
+}