@shareai-lab/kode 1.1.14 → 1.1.16-dev.2

package/src/screens/ResumeConversation.tsx

@@ -1,68 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,66 +0,0 @@
-// 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
-}