@shareai-lab/kode 1.0.70 → 1.0.73

package/src/screens/ResumeConversation.tsx

@@ -0,0 +1,68 @@
+import React from 'react'
+import { render } from 'ink'
+import { REPL } from './REPL'
+import { deserializeMessages } from '../utils/conversationRecovery'
+import { LogSelector } from '../components/LogSelector'
+import type { LogOption } from '../types/logs'
+import { logError, getNextAvailableLogForkNumber } from '../utils/log'
+import type { Tool } from '../Tool'
+import { Command } from '../commands'
+import { isDefaultSlowAndCapableModel } from '../utils/model'
+
+type Props = {
+  commands: Command[]
+  context: { unmount?: () => void }
+  logs: LogOption[]
+  tools: Tool[]
+  verbose: boolean | undefined
+}
+
+export function ResumeConversation({
+  context,
+  commands,
+  logs,
+  tools,
+  verbose,
+}: Props): React.ReactNode {
+  async function onSelect(index: number) {
+    const log = logs[index]
+    if (!log) {
+      return
+    }
+
+    // Load and deserialize the messages
+    try {
+      context.unmount?.()
+      // Start a new REPL with the loaded messages
+      // Increment the fork number by 1 to generate a new transcript
+      // Check if using default model before rendering
+      const isDefaultModel = await isDefaultSlowAndCapableModel()
+
+      render(
+        <REPL
+          messageLogName={log.date}
+          initialPrompt=""
+          shouldShowPromptInput={true}
+          verbose={verbose}
+          commands={commands}
+          tools={tools}
+          initialMessages={deserializeMessages(log.messages, tools)}
+          initialForkNumber={getNextAvailableLogForkNumber(
+            log.date,
+            log.forkNumber ?? 1,
+            0,
+          )}
+          isDefaultModel={isDefaultModel}
+        />,
+        {
+          exitOnCtrlC: false,
+        },
+      )
+    } catch (e) {
+      logError(`Failed to load conversation: ${e}`)
+      throw e
+    }
+  }
+
+  return <LogSelector logs={logs} onSelect={onSelect} />
+}

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
+      }))
+  }
+}

package/src/services/browserMocks.ts

@@ -0,0 +1,66 @@
+// Mock browser APIs needed by @statsig/js-client in Node.js environment
+
+// Document mock with visibility state tracking
+const mockDocument = {
+  visibilityState: 'visible' as const,
+  documentElement: {
+    lang: 'en',
+  },
+  addEventListener: (
+    _event: string,
+    _handler: EventListenerOrEventListenerObject,
+  ) => {
+    // Visibility change events are handled through window.document reference
+  },
+} as const
+
+// Window mock with focus/blur and beforeunload handling
+export const mockWindow = {
+  document: mockDocument,
+  location: {
+    href: 'node://localhost',
+    pathname: '/',
+  },
+  addEventListener: (
+    event: string,
+    handler: EventListenerOrEventListenerObject,
+  ) => {
+    if (event === 'beforeunload') {
+      // Capture beforeunload handlers and run them on process exit
+      process.on('exit', () => {
+        if (typeof handler === 'function') {
+          handler({} as Event)
+        } else {
+          handler.handleEvent({} as Event)
+        }
+      })
+    }
+    // Other events (focus/blur) are not critically needed in Node.js
+  },
+  focus: () => {
+    // Focus is a no-op in Node.js
+  },
+  innerHeight: 768,
+  innerWidth: 1024,
+} as const
+
+// Navigator mock with minimal beacon support
+export const mockNavigator = {
+  sendBeacon: (_url: string, _data: string | Blob): boolean => {
+    // Beacons are used for analytics - return success but don't actually send
+    return true
+  },
+  userAgent:
+    'Mozilla/5.0 (Node.js) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0',
+  language: 'en-US',
+} as const
+
+// Only assign mocks if running in Node.js environment
+if (typeof window === 'undefined') {
+  // @ts-expect-error: intentionally applying partial mocks for Node.js environment
+  global.window = mockWindow
+}
+if (typeof navigator === 'undefined') {
+  // @ts-expect-error: intentionally applying partial mocks for Node.js environment
+  global.navigator = mockNavigator
+}