@shareai-lab/kode 1.0.9

package/src/services/openai.ts

@@ -0,0 +1,1338 @@
+import { OpenAI } from 'openai'
+import { getGlobalConfig, GlobalConfig } from '../utils/config'
+import { ProxyAgent, fetch, Response } from 'undici'
+import { setSessionState, getSessionState } from '../utils/sessionState'
+import { logEvent } from '../services/statsig'
+import { debug as debugLogger, getCurrentRequest, logAPIError } from '../utils/debugLogger'
+
+// Helper function to calculate retry delay with exponential backoff
+function getRetryDelay(attempt: number, retryAfter?: string | null): number {
+  // If server suggests a retry-after time, use it
+  if (retryAfter) {
+    const retryAfterMs = parseInt(retryAfter) * 1000
+    if (!isNaN(retryAfterMs) && retryAfterMs > 0) {
+      return Math.min(retryAfterMs, 60000) // Cap at 60 seconds
+    }
+  }
+
+  // Exponential backoff: base delay of 1 second, doubling each attempt
+  const baseDelay = 1000
+  const maxDelay = 32000 // Cap at 32 seconds
+  const delay = baseDelay * Math.pow(2, attempt - 1)
+
+  // Add some jitter to avoid thundering herd
+  const jitter = Math.random() * 0.1 * delay
+
+  return Math.min(delay + jitter, maxDelay)
+}
+
+// Helper function to create an abortable delay
+function abortableDelay(delayMs: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    // Check if already aborted
+    if (signal?.aborted) {
+      reject(new Error('Request was aborted'))
+      return
+    }
+
+    const timeoutId = setTimeout(() => {
+      resolve()
+    }, delayMs)
+
+    // If signal is provided, listen for abort event
+    if (signal) {
+      const abortHandler = () => {
+        clearTimeout(timeoutId)
+        reject(new Error('Request was aborted'))
+      }
+      signal.addEventListener('abort', abortHandler, { once: true })
+    }
+  })
+}
+
+enum ModelErrorType {
+  MaxLength = '1024',
+  MaxCompletionTokens = 'max_completion_tokens',
+  TemperatureRestriction = 'temperature_restriction',
+  StreamOptions = 'stream_options',
+  Citations = 'citations',
+  RateLimit = 'rate_limit',
+}
+
+function getModelErrorKey(
+  baseURL: string,
+  model: string,
+  type: ModelErrorType,
+): string {
+  return `${baseURL}:${model}:${type}`
+}
+
+function hasModelError(
+  baseURL: string,
+  model: string,
+  type: ModelErrorType,
+): boolean {
+  return !!getSessionState('modelErrors')[
+    getModelErrorKey(baseURL, model, type)
+  ]
+}
+
+function setModelError(
+  baseURL: string,
+  model: string,
+  type: ModelErrorType,
+  error: string,
+) {
+  setSessionState('modelErrors', {
+    [getModelErrorKey(baseURL, model, type)]: error,
+  })
+}
+
+// More flexible error detection system
+type ErrorDetector = (errMsg: string) => boolean
+type ErrorFixer = (
+  opts: OpenAI.ChatCompletionCreateParams,
+) => Promise<void> | void
+interface ErrorHandler {
+  type: ModelErrorType
+  detect: ErrorDetector
+  fix: ErrorFixer
+}
+
+// GPT-5 specific error handlers with enhanced detection patterns
+const GPT5_ERROR_HANDLERS: ErrorHandler[] = [
+  {
+    type: ModelErrorType.MaxCompletionTokens,
+    detect: errMsg => {
+      const lowerMsg = errMsg.toLowerCase()
+      return (
+        // Exact OpenAI GPT-5 error message
+        (lowerMsg.includes("unsupported parameter: 'max_tokens'") && lowerMsg.includes("'max_completion_tokens'")) ||
+        // Generic max_tokens error patterns
+        (lowerMsg.includes("max_tokens") && lowerMsg.includes("max_completion_tokens")) ||
+        (lowerMsg.includes("max_tokens") && lowerMsg.includes("not supported")) ||
+        (lowerMsg.includes("max_tokens") && lowerMsg.includes("use max_completion_tokens")) ||
+        // Additional patterns for various providers
+        (lowerMsg.includes("invalid parameter") && lowerMsg.includes("max_tokens")) ||
+        (lowerMsg.includes("parameter error") && lowerMsg.includes("max_tokens"))
+      )
+    },
+    fix: async opts => {
+      console.log(`🔧 GPT-5 Fix: Converting max_tokens (${opts.max_tokens}) to max_completion_tokens`)
+      if ('max_tokens' in opts) {
+        opts.max_completion_tokens = opts.max_tokens
+        delete opts.max_tokens
+      }
+    },
+  },
+  {
+    type: ModelErrorType.TemperatureRestriction,
+    detect: errMsg => {
+      const lowerMsg = errMsg.toLowerCase()
+      return (
+        lowerMsg.includes("temperature") && 
+        (lowerMsg.includes("only supports") || lowerMsg.includes("must be 1") || lowerMsg.includes("invalid temperature"))
+      )
+    },
+    fix: async opts => {
+      console.log(`🔧 GPT-5 Fix: Adjusting temperature from ${opts.temperature} to 1`)
+      opts.temperature = 1
+    },
+  },
+  // Add more GPT-5 specific handlers as needed
+]
+
+// Standard error handlers
+const ERROR_HANDLERS: ErrorHandler[] = [
+  {
+    type: ModelErrorType.MaxLength,
+    detect: errMsg =>
+      errMsg.includes('Expected a string with maximum length 1024'),
+    fix: async opts => {
+      const toolDescriptions = {}
+      for (const tool of opts.tools || []) {
+        if (tool.function.description.length <= 1024) continue
+        let str = ''
+        let remainder = ''
+        for (let line of tool.function.description.split('\n')) {
+          if (str.length + line.length < 1024) {
+            str += line + '\n'
+          } else {
+            remainder += line + '\n'
+          }
+        }
+        logEvent('truncated_tool_description', {
+          name: tool.function.name,
+          original_length: String(tool.function.description.length),
+          truncated_length: String(str.length),
+          remainder_length: String(remainder.length),
+        })
+        tool.function.description = str
+        toolDescriptions[tool.function.name] = remainder
+      }
+      if (Object.keys(toolDescriptions).length > 0) {
+        let content = '<additional-tool-usage-instructions>\n\n'
+        for (const [name, description] of Object.entries(toolDescriptions)) {
+          content += `<${name}>\n${description}\n</${name}>\n\n`
+        }
+        content += '</additional-tool-usage-instructions>'
+
+        for (let i = opts.messages.length - 1; i >= 0; i--) {
+          if (opts.messages[i].role === 'system') {
+            opts.messages.splice(i + 1, 0, {
+              role: 'system',
+              content,
+            })
+            break
+          }
+        }
+      }
+    },
+  },
+  {
+    type: ModelErrorType.MaxCompletionTokens,
+    detect: errMsg => errMsg.includes("Use 'max_completion_tokens'"),
+    fix: async opts => {
+      opts.max_completion_tokens = opts.max_tokens
+      delete opts.max_tokens
+    },
+  },
+  {
+    type: ModelErrorType.StreamOptions,
+    detect: errMsg => errMsg.includes('stream_options'),
+    fix: async opts => {
+      delete opts.stream_options
+    },
+  },
+  {
+    type: ModelErrorType.Citations,
+    detect: errMsg =>
+      errMsg.includes('Extra inputs are not permitted') &&
+      errMsg.includes('citations'),
+    fix: async opts => {
+      if (!opts.messages) return
+
+      for (const message of opts.messages) {
+        if (!message) continue
+
+        if (Array.isArray(message.content)) {
+          for (const item of message.content) {
+            // Convert to unknown first to safely access properties
+            if (item && typeof item === 'object') {
+              const itemObj = item as unknown as Record<string, unknown>
+              if ('citations' in itemObj) {
+                delete itemObj.citations
+              }
+            }
+          }
+        } else if (message.content && typeof message.content === 'object') {
+          // Convert to unknown first to safely access properties
+          const contentObj = message.content as unknown as Record<
+            string,
+            unknown
+          >
+          if ('citations' in contentObj) {
+            delete contentObj.citations
+          }
+        }
+      }
+    },
+  },
+]
+
+// Rate limit specific detection
+function isRateLimitError(errMsg: string): boolean {
+  if (!errMsg) return false
+  const lowerMsg = errMsg.toLowerCase()
+  return (
+    lowerMsg.includes('rate limit') ||
+    lowerMsg.includes('too many requests') ||
+    lowerMsg.includes('429')
+  )
+}
+
+// Model-specific feature flags - can be extended with more properties as needed
+interface ModelFeatures {
+  usesMaxCompletionTokens: boolean
+  supportsResponsesAPI?: boolean
+  requiresTemperatureOne?: boolean
+  supportsVerbosityControl?: boolean
+  supportsCustomTools?: boolean
+  supportsAllowedTools?: boolean
+}
+
+// Map of model identifiers to their specific features
+const MODEL_FEATURES: Record<string, ModelFeatures> = {
+  // OpenAI thinking models
+  o1: { usesMaxCompletionTokens: true },
+  'o1-preview': { usesMaxCompletionTokens: true },
+  'o1-mini': { usesMaxCompletionTokens: true },
+  'o1-pro': { usesMaxCompletionTokens: true },
+  'o3-mini': { usesMaxCompletionTokens: true },
+  // GPT-5 models
+  'gpt-5': { 
+    usesMaxCompletionTokens: true, 
+    supportsResponsesAPI: true,
+    requiresTemperatureOne: true,
+    supportsVerbosityControl: true,
+    supportsCustomTools: true,
+    supportsAllowedTools: true,
+  },
+  'gpt-5-mini': { 
+    usesMaxCompletionTokens: true, 
+    supportsResponsesAPI: true,
+    requiresTemperatureOne: true,
+    supportsVerbosityControl: true,
+    supportsCustomTools: true,
+    supportsAllowedTools: true,
+  },
+  'gpt-5-nano': { 
+    usesMaxCompletionTokens: true, 
+    supportsResponsesAPI: true,
+    requiresTemperatureOne: true,
+    supportsVerbosityControl: true,
+    supportsCustomTools: true,
+    supportsAllowedTools: true,
+  },
+  'gpt-5-chat-latest': { 
+    usesMaxCompletionTokens: true, 
+    supportsResponsesAPI: false, // Uses Chat Completions only
+    requiresTemperatureOne: true,
+    supportsVerbosityControl: true,
+  },
+}
+
+// Helper to get model features based on model ID/name
+function getModelFeatures(modelName: string): ModelFeatures {
+  if (!modelName || typeof modelName !== 'string') {
+    return { usesMaxCompletionTokens: false }
+  }
+
+  // Check for exact matches first (highest priority)
+  if (MODEL_FEATURES[modelName]) {
+    return MODEL_FEATURES[modelName]
+  }
+
+  // Simple GPT-5 detection: any model name containing 'gpt-5'
+  if (modelName.toLowerCase().includes('gpt-5')) {
+    return {
+      usesMaxCompletionTokens: true,
+      supportsResponsesAPI: true,
+      requiresTemperatureOne: true,
+      supportsVerbosityControl: true,
+      supportsCustomTools: true,
+      supportsAllowedTools: true,
+    }
+  }
+
+  // Check for partial matches (e.g., other reasoning models)
+  for (const [key, features] of Object.entries(MODEL_FEATURES)) {
+    if (modelName.includes(key)) {
+      return features
+    }
+  }
+
+  // Default features for unknown models
+  return { usesMaxCompletionTokens: false }
+}
+
+// Apply model-specific parameter transformations based on model features
+function applyModelSpecificTransformations(
+  opts: OpenAI.ChatCompletionCreateParams,
+): void {
+  if (!opts.model || typeof opts.model !== 'string') {
+    return
+  }
+
+  const features = getModelFeatures(opts.model)
+  const isGPT5 = opts.model.toLowerCase().includes('gpt-5')
+
+  // 🔥 Enhanced GPT-5 Detection and Transformation
+  if (isGPT5 || features.usesMaxCompletionTokens) {
+    // Force max_completion_tokens for all GPT-5 models
+    if ('max_tokens' in opts && !('max_completion_tokens' in opts)) {
+      console.log(`🔧 Transforming max_tokens (${opts.max_tokens}) to max_completion_tokens for ${opts.model}`)
+      opts.max_completion_tokens = opts.max_tokens
+      delete opts.max_tokens
+    }
+    
+    // Force temperature = 1 for GPT-5 models
+    if (features.requiresTemperatureOne && 'temperature' in opts) {
+      if (opts.temperature !== 1 && opts.temperature !== undefined) {
+        console.log(
+          `🔧 GPT-5 temperature constraint: Adjusting temperature from ${opts.temperature} to 1 for ${opts.model}`
+        )
+        opts.temperature = 1
+      }
+    }
+    
+    // Remove unsupported parameters for GPT-5
+    if (isGPT5) {
+      // Remove parameters that may not be supported by GPT-5
+      delete opts.frequency_penalty
+      delete opts.presence_penalty
+      delete opts.logit_bias
+      delete opts.user
+      
+      // Add reasoning_effort if not present and model supports it
+      if (!opts.reasoning_effort && features.supportsVerbosityControl) {
+        opts.reasoning_effort = 'medium' // Default reasoning effort for coding tasks
+      }
+    }
+  }
+
+  // Apply transformations for non-GPT-5 models
+  else {
+    // Standard max_tokens to max_completion_tokens conversion for other reasoning models
+    if (
+      features.usesMaxCompletionTokens &&
+      'max_tokens' in opts &&
+      !('max_completion_tokens' in opts)
+    ) {
+      opts.max_completion_tokens = opts.max_tokens
+      delete opts.max_tokens
+    }
+  }
+
+  // Add more transformations here as needed
+}
+
+async function applyModelErrorFixes(
+  opts: OpenAI.ChatCompletionCreateParams,
+  baseURL: string,
+) {
+  const isGPT5 = opts.model.startsWith('gpt-5')
+  const handlers = isGPT5 ? [...GPT5_ERROR_HANDLERS, ...ERROR_HANDLERS] : ERROR_HANDLERS
+  
+  for (const handler of handlers) {
+    if (hasModelError(baseURL, opts.model, handler.type)) {
+      await handler.fix(opts)
+      return
+    }
+  }
+}
+
+// Helper function to try different endpoints for OpenAI-compatible providers
+async function tryWithEndpointFallback(
+  baseURL: string,
+  opts: OpenAI.ChatCompletionCreateParams,
+  headers: Record<string, string>,
+  provider: string,
+  proxy: any,
+  signal?: AbortSignal, // 🔧 Add AbortSignal support
+): Promise<{ response: Response; endpoint: string }> {
+  const endpointsToTry = []
+
+  if (provider === 'minimax') {
+    endpointsToTry.push('/text/chatcompletion_v2', '/chat/completions')
+  } else {
+    endpointsToTry.push('/chat/completions')
+  }
+
+  let lastError = null
+
+  for (const endpoint of endpointsToTry) {
+    try {
+      const response = await fetch(`${baseURL}${endpoint}`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(opts.stream ? { ...opts, stream: true } : opts),
+        dispatcher: proxy,
+        signal: signal, // 🔧 Connect AbortSignal to fetch call
+      })
+
+      // If successful, return immediately
+      if (response.ok) {
+        return { response, endpoint }
+      }
+
+      // If it's a 404, try the next endpoint
+      if (response.status === 404 && endpointsToTry.length > 1) {
+        console.log(
+          `Endpoint ${endpoint} returned 404, trying next endpoint...`,
+        )
+        continue
+      }
+
+      // For other error codes, return this response (don't try fallback)
+      return { response, endpoint }
+    } catch (error) {
+      lastError = error
+      // Network errors might be temporary, try next endpoint
+      if (endpointsToTry.indexOf(endpoint) < endpointsToTry.length - 1) {
+        console.log(`Network error on ${endpoint}, trying next endpoint...`)
+        continue
+      }
+    }
+  }
+
+  // If we get here, all endpoints failed
+  throw lastError || new Error('All endpoints failed')
+}
+
+// Export shared utilities for GPT-5 compatibility
+export { getGPT5CompletionWithProfile, getModelFeatures, applyModelSpecificTransformations }
+
+export async function getCompletionWithProfile(
+  modelProfile: any,
+  opts: OpenAI.ChatCompletionCreateParams,
+  attempt: number = 0,
+  maxAttempts: number = 10,
+  signal?: AbortSignal, // 🔧 CRITICAL FIX: Add AbortSignal support
+): Promise<OpenAI.ChatCompletion | AsyncIterable<OpenAI.ChatCompletionChunk>> {
+  if (attempt >= maxAttempts) {
+    throw new Error('Max attempts reached')
+  }
+
+  const provider = modelProfile?.provider || 'anthropic'
+  const baseURL = modelProfile?.baseURL
+  const apiKey = modelProfile?.apiKey
+  const proxy = getGlobalConfig().proxy
+    ? new ProxyAgent(getGlobalConfig().proxy)
+    : undefined
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  }
+
+  if (apiKey) {
+    if (provider === 'azure') {
+      headers['api-key'] = apiKey
+    } else {
+      headers['Authorization'] = `Bearer ${apiKey}`
+    }
+  }
+
+  applyModelSpecificTransformations(opts)
+  await applyModelErrorFixes(opts, baseURL || '')
+
+  // 🔥 REAL-TIME API CALL DEBUG - 使用全局日志系统
+  debugLogger.api('OPENAI_API_CALL_START', {
+    endpoint: baseURL || 'DEFAULT_OPENAI',
+    model: opts.model,
+    provider,
+    apiKeyConfigured: !!apiKey,
+    apiKeyPrefix: apiKey ? apiKey.substring(0, 8) : null,
+    maxTokens: opts.max_tokens,
+    temperature: opts.temperature,
+    messageCount: opts.messages?.length || 0,
+    streamMode: opts.stream,
+    timestamp: new Date().toISOString(),
+    modelProfileModelName: modelProfile?.modelName,
+    modelProfileName: modelProfile?.name,
+  })
+
+  // Make sure all tool messages have string content
+  opts.messages = opts.messages.map(msg => {
+    if (msg.role === 'tool') {
+      if (Array.isArray(msg.content)) {
+        return {
+          ...msg,
+          content:
+            msg.content
+              .map(c => c.text || '')
+              .filter(Boolean)
+              .join('\n\n') || '(empty content)',
+        }
+      } else if (typeof msg.content !== 'string') {
+        return {
+          ...msg,
+          content:
+            typeof msg.content === 'undefined'
+              ? '(empty content)'
+              : JSON.stringify(msg.content),
+        }
+      }
+    }
+    return msg
+  })
+
+  // Define Azure-specific API endpoint with version
+  const azureApiVersion = '2024-06-01'
+  let endpoint = '/chat/completions'
+
+  if (provider === 'azure') {
+    endpoint = `/chat/completions?api-version=${azureApiVersion}`
+  } else if (provider === 'minimax') {
+    endpoint = '/text/chatcompletion_v2'
+  }
+
+  try {
+    if (opts.stream) {
+      const isOpenAICompatible = [
+        'minimax',
+        'kimi',
+        'deepseek',
+        'siliconflow',
+        'qwen',
+        'glm',
+        'baidu-qianfan',
+        'openai',
+        'mistral',
+        'xai',
+        'groq',
+        'custom-openai',
+      ].includes(provider)
+
+      let response: Response
+      let usedEndpoint: string
+
+      if (isOpenAICompatible && provider !== 'azure') {
+        const result = await tryWithEndpointFallback(
+          baseURL,
+          opts,
+          headers,
+          provider,
+          proxy,
+          signal, // 🔧 Pass AbortSignal to endpoint fallback
+        )
+        response = result.response
+        usedEndpoint = result.endpoint
+      } else {
+        response = await fetch(`${baseURL}${endpoint}`, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({ ...opts, stream: true }),
+          dispatcher: proxy,
+          signal: signal, // 🔧 CRITICAL FIX: Connect AbortSignal to fetch call
+        })
+        usedEndpoint = endpoint
+      }
+
+      if (!response.ok) {
+        // 🔧 CRITICAL FIX: Check abort signal BEFORE showing retry message
+        if (signal?.aborted) {
+          throw new Error('Request cancelled by user')
+        }
+        
+        // 🔥 NEW: Parse error message to detect and handle specific API errors
+        try {
+          const errorData = await response.json()
+          const errorMessage = errorData?.error?.message || errorData?.message || `HTTP ${response.status}`
+          
+          // Check if this is a parameter error that we can fix
+          const isGPT5 = opts.model.startsWith('gpt-5')
+          const handlers = isGPT5 ? [...GPT5_ERROR_HANDLERS, ...ERROR_HANDLERS] : ERROR_HANDLERS
+          
+          for (const handler of handlers) {
+            if (handler.detect(errorMessage)) {
+              console.log(`🔧 Detected ${handler.type} error for ${opts.model}: ${errorMessage}`)
+              
+              // Store this error for future requests
+              setModelError(baseURL || '', opts.model, handler.type, errorMessage)
+              
+              // Apply the fix and retry immediately
+              await handler.fix(opts)
+              console.log(`🔧 Applied fix for ${handler.type}, retrying...`)
+              
+              return getCompletionWithProfile(
+                modelProfile,
+                opts,
+                attempt + 1,
+                maxAttempts,
+                signal,
+              )
+            }
+          }
+          
+          // If no specific handler found, log the error for debugging
+          console.log(`⚠️  Unhandled API error (${response.status}): ${errorMessage}`)
+          
+          // Log API error using unified logger
+          logAPIError({
+            model: opts.model,
+            endpoint: `${baseURL}${endpoint}`,
+            status: response.status,
+            error: errorMessage,
+            request: opts,
+            response: errorData,
+            provider: provider
+          })
+        } catch (parseError) {
+          // If we can't parse the error, fall back to generic retry
+          console.log(`⚠️  Could not parse error response (${response.status})`)
+          
+          // Log parse error
+          logAPIError({
+            model: opts.model,
+            endpoint: `${baseURL}${endpoint}`,
+            status: response.status,
+            error: `Could not parse error response: ${parseError.message}`,
+            request: opts,
+            response: { parseError: parseError.message },
+            provider: provider
+          })
+        }
+        
+        const delayMs = getRetryDelay(attempt)
+        console.log(
+          `  ⎿  API error (${response.status}), retrying in ${Math.round(delayMs / 1000)}s... (attempt ${attempt + 1}/${maxAttempts})`,
+        )
+        try {
+          await abortableDelay(delayMs, signal)
+        } catch (error) {
+          // If aborted during delay, throw the error to stop retrying
+          if (error.message === 'Request was aborted') {
+            throw new Error('Request cancelled by user')
+          }
+          throw error
+        }
+        return getCompletionWithProfile(
+          modelProfile,
+          opts,
+          attempt + 1,
+          maxAttempts,
+          signal, // 🔧 Pass AbortSignal to recursive call
+        )
+      }
+
+      const stream = createStreamProcessor(response.body as any, signal)
+      return stream
+    }
+
+    // Non-streaming request
+    const isOpenAICompatible = [
+      'minimax',
+      'kimi',
+      'deepseek',
+      'siliconflow',
+      'qwen',
+      'glm',
+      'baidu-qianfan',
+      'openai',
+      'mistral',
+      'xai',
+      'groq',
+      'custom-openai',
+    ].includes(provider)
+
+    let response: Response
+    let usedEndpoint: string
+
+    if (isOpenAICompatible && provider !== 'azure') {
+      const result = await tryWithEndpointFallback(
+        baseURL,
+        opts,
+        headers,
+        provider,
+        proxy,
+        signal, // 🔧 Pass AbortSignal to endpoint fallback
+      )
+      response = result.response
+      usedEndpoint = result.endpoint
+    } else {
+      response = await fetch(`${baseURL}${endpoint}`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(opts),
+        dispatcher: proxy,
+        signal: signal, // 🔧 CRITICAL FIX: Connect AbortSignal to non-streaming fetch call
+      })
+      usedEndpoint = endpoint
+    }
+
+    if (!response.ok) {
+      // 🔧 CRITICAL FIX: Check abort signal BEFORE showing retry message
+      if (signal?.aborted) {
+        throw new Error('Request cancelled by user')
+      }
+      
+      // 🔥 NEW: Parse error message to detect and handle specific API errors
+      try {
+        const errorData = await response.json()
+        const errorMessage = errorData?.error?.message || errorData?.message || `HTTP ${response.status}`
+        
+        // Check if this is a parameter error that we can fix
+        const isGPT5 = opts.model.startsWith('gpt-5')
+        const handlers = isGPT5 ? [...GPT5_ERROR_HANDLERS, ...ERROR_HANDLERS] : ERROR_HANDLERS
+        
+        for (const handler of handlers) {
+          if (handler.detect(errorMessage)) {
+            console.log(`🔧 Detected ${handler.type} error for ${opts.model}: ${errorMessage}`)
+            
+            // Store this error for future requests
+            setModelError(baseURL || '', opts.model, handler.type, errorMessage)
+            
+            // Apply the fix and retry immediately
+            await handler.fix(opts)
+            console.log(`🔧 Applied fix for ${handler.type}, retrying...`)
+            
+            return getCompletionWithProfile(
+              modelProfile,
+              opts,
+              attempt + 1,
+              maxAttempts,
+              signal,
+            )
+          }
+        }
+        
+        // If no specific handler found, log the error for debugging
+        console.log(`⚠️  Unhandled API error (${response.status}): ${errorMessage}`)
+      } catch (parseError) {
+        // If we can't parse the error, fall back to generic retry
+        console.log(`⚠️  Could not parse error response (${response.status})`)
+      }
+      
+      const delayMs = getRetryDelay(attempt)
+      console.log(
+        `  ⎿  API error (${response.status}), retrying in ${Math.round(delayMs / 1000)}s... (attempt ${attempt + 1}/${maxAttempts})`,
+      )
+      try {
+        await abortableDelay(delayMs, signal)
+      } catch (error) {
+        // If aborted during delay, throw the error to stop retrying
+        if (error.message === 'Request was aborted') {
+          throw new Error('Request cancelled by user')
+        }
+        throw error
+      }
+      return getCompletionWithProfile(
+        modelProfile,
+        opts,
+        attempt + 1,
+        maxAttempts,
+        signal, // 🔧 Pass AbortSignal to recursive call
+      )
+    }
+
+    const responseData = (await response.json()) as OpenAI.ChatCompletion
+    return responseData
+  } catch (error) {
+    // 🔧 CRITICAL FIX: Check abort signal BEFORE showing retry message
+    if (signal?.aborted) {
+      throw new Error('Request cancelled by user')
+    }
+    
+    if (attempt < maxAttempts) {
+      // 🔧 Double-check abort status to avoid showing misleading retry message
+      if (signal?.aborted) {
+        throw new Error('Request cancelled by user')
+      }
+      
+      const delayMs = getRetryDelay(attempt)
+      console.log(
+        `  ⎿  Network error, retrying in ${Math.round(delayMs / 1000)}s... (attempt ${attempt + 1}/${maxAttempts})`,
+      )
+      try {
+        await abortableDelay(delayMs, signal)
+      } catch (error) {
+        // If aborted during delay, throw the error to stop retrying
+        if (error.message === 'Request was aborted') {
+          throw new Error('Request cancelled by user')
+        }
+        throw error
+      }
+      return getCompletionWithProfile(
+        modelProfile,
+        opts,
+        attempt + 1,
+        maxAttempts,
+        signal, // 🔧 Pass AbortSignal to recursive call
+      )
+    }
+    throw error
+  }
+}
+
+export function createStreamProcessor(
+  stream: any,
+  signal?: AbortSignal,
+): AsyncGenerator<OpenAI.ChatCompletionChunk, void, unknown> {
+  if (!stream) {
+    throw new Error('Stream is null or undefined')
+  }
+
+  return (async function* () {
+    const reader = stream.getReader()
+    const decoder = new TextDecoder('utf-8')
+    let buffer = ''
+
+    try {
+      while (true) {
+        // Check for cancellation before attempting to read
+        if (signal?.aborted) {
+          break
+        }
+
+        let readResult
+        try {
+          readResult = await reader.read()
+        } catch (e) {
+          // If signal is aborted, this is user cancellation - exit silently
+          if (signal?.aborted) {
+            break
+          }
+          console.error('Error reading from stream:', e)
+          break
+        }
+
+        const { done, value } = readResult
+        if (done) {
+          break
+        }
+
+        const chunk = decoder.decode(value, { stream: true })
+        buffer += chunk
+
+        let lineEnd = buffer.indexOf('\n')
+        while (lineEnd !== -1) {
+          const line = buffer.substring(0, lineEnd).trim()
+          buffer = buffer.substring(lineEnd + 1)
+
+          if (line === 'data: [DONE]') {
+            continue
+          }
+
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6).trim()
+            if (!data) continue
+
+            try {
+              const parsed = JSON.parse(data) as OpenAI.ChatCompletionChunk
+              yield parsed
+            } catch (e) {
+              console.error('Error parsing JSON:', data, e)
+            }
+          }
+
+          lineEnd = buffer.indexOf('\n')
+        }
+      }
+
+      // Process any remaining data in the buffer
+      if (buffer.trim()) {
+        const lines = buffer.trim().split('\n')
+        for (const line of lines) {
+          if (line.startsWith('data: ') && line !== 'data: [DONE]') {
+            const data = line.slice(6).trim()
+            if (!data) continue
+
+            try {
+              const parsed = JSON.parse(data) as OpenAI.ChatCompletionChunk
+              yield parsed
+            } catch (e) {
+              console.error('Error parsing final JSON:', data, e)
+            }
+          }
+        }
+      }
+    } catch (e) {
+      console.error('Unexpected error in stream processing:', e)
+    } finally {
+      try {
+        reader.releaseLock()
+      } catch (e) {
+        console.error('Error releasing reader lock:', e)
+      }
+    }
+  })()
+}
+
+export function streamCompletion(
+  stream: any,
+  signal?: AbortSignal,
+): AsyncGenerator<OpenAI.ChatCompletionChunk, void, unknown> {
+  return createStreamProcessor(stream, signal)
+}
+
+/**
+ * Call GPT-5 Responses API with proper parameter handling
+ */
+export async function callGPT5ResponsesAPI(
+  modelProfile: any,
+  opts: any, // Using 'any' for Responses API params which differ from ChatCompletionCreateParams
+  signal?: AbortSignal,
+): Promise<any> {
+  const baseURL = modelProfile?.baseURL || 'https://api.openai.com/v1'
+  const apiKey = modelProfile?.apiKey
+  const proxy = getGlobalConfig().proxy
+    ? new ProxyAgent(getGlobalConfig().proxy)
+    : undefined
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${apiKey}`,
+  }
+
+  // 🔥 Enhanced Responses API Parameter Mapping for GPT-5
+  const responsesParams: any = {
+    model: opts.model,
+    input: opts.messages, // Responses API uses 'input' instead of 'messages'
+  }
+
+  // 🔧 GPT-5 Token Configuration
+  if (opts.max_completion_tokens) {
+    responsesParams.max_completion_tokens = opts.max_completion_tokens
+  } else if (opts.max_tokens) {
+    // Fallback conversion if max_tokens is still present
+    responsesParams.max_completion_tokens = opts.max_tokens
+  }
+
+  // 🔧 GPT-5 Temperature Handling (only 1 or undefined)
+  if (opts.temperature === 1) {
+    responsesParams.temperature = 1
+  }
+  // Note: Do not pass temperature if it's not 1, GPT-5 will use default
+
+  // 🔧 GPT-5 Reasoning Configuration
+  const reasoningEffort = opts.reasoning_effort || 'medium'
+  responsesParams.reasoning = {
+    effort: reasoningEffort,
+    // 🚀 Enable reasoning summaries for transparency in coding tasks
+    generate_summary: true,
+  }
+
+  // 🔧 GPT-5 Tools Support
+  if (opts.tools && opts.tools.length > 0) {
+    responsesParams.tools = opts.tools
+    
+    // 🚀 GPT-5 Tool Choice Configuration
+    if (opts.tool_choice) {
+      responsesParams.tool_choice = opts.tool_choice
+    }
+  }
+
+  // 🔧 GPT-5 System Instructions (separate from messages)
+  const systemMessages = opts.messages.filter(msg => msg.role === 'system')
+  const nonSystemMessages = opts.messages.filter(msg => msg.role !== 'system')
+  
+  if (systemMessages.length > 0) {
+    responsesParams.instructions = systemMessages.map(msg => msg.content).join('\n\n')
+    responsesParams.input = nonSystemMessages
+  }
+
+  // Handle verbosity (if supported) - optimized for coding tasks
+  const features = getModelFeatures(opts.model)
+  if (features.supportsVerbosityControl) {
+    // High verbosity for coding tasks to get detailed explanations and structured code
+    // Based on GPT-5 best practices for agent-like coding environments
+    responsesParams.text = {
+      verbosity: 'high',
+    }
+  }
+
+  // Apply GPT-5 coding optimizations
+  if (opts.model.startsWith('gpt-5')) {
+    // Set reasoning effort based on task complexity
+    if (!responsesParams.reasoning) {
+      responsesParams.reasoning = {
+        effort: 'medium', // Balanced for most coding tasks
+      }
+    }
+
+    // Add instructions parameter for coding-specific guidance
+    if (!responsesParams.instructions) {
+      responsesParams.instructions = `You are an expert programmer working in a terminal-based coding environment. Follow these guidelines:
+- Provide clear, concise code solutions
+- Use proper error handling and validation
+- Follow coding best practices and patterns
+- Explain complex logic when necessary
+- Focus on maintainable, readable code`
+    }
+  }
+
+  try {
+    const response = await fetch(`${baseURL}/responses`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(responsesParams),
+      dispatcher: proxy,
+      signal: signal,
+    })
+
+    if (!response.ok) {
+      throw new Error(`GPT-5 Responses API error: ${response.status} ${response.statusText}`)
+    }
+
+    const responseData = await response.json()
+    
+    // Convert Responses API response back to Chat Completion format for compatibility
+    return convertResponsesAPIToChatCompletion(responseData)
+  } catch (error) {
+    if (signal?.aborted) {
+      throw new Error('Request cancelled by user')
+    }
+    throw error
+  }
+}
+
+/**
+ * Convert Responses API response to Chat Completion format for compatibility
+ * 🔥 Enhanced for GPT-5 with reasoning summary support
+ */
+function convertResponsesAPIToChatCompletion(responsesData: any): any {
+  // Extract content from Responses API format
+  let outputText = responsesData.output_text || ''
+  const usage = responsesData.usage || {}
+  
+  // 🚀 GPT-5 Reasoning Summary Integration
+  // If reasoning summary is available, prepend it to the output for transparency
+  if (responsesData.output && Array.isArray(responsesData.output)) {
+    const reasoningItems = responsesData.output.filter(item => item.type === 'reasoning' && item.summary)
+    const messageItems = responsesData.output.filter(item => item.type === 'message')
+    
+    if (reasoningItems.length > 0 && messageItems.length > 0) {
+      const reasoningSummary = reasoningItems
+        .map(item => item.summary?.map(s => s.text).join('\n'))
+        .filter(Boolean)
+        .join('\n\n')
+      
+      const mainContent = messageItems
+        .map(item => item.content?.map(c => c.text).join('\n'))
+        .filter(Boolean)
+        .join('\n\n')
+      
+      if (reasoningSummary) {
+        outputText = `**🧠 Reasoning Process:**\n${reasoningSummary}\n\n**📝 Response:**\n${mainContent}`
+      } else {
+        outputText = mainContent
+      }
+    }
+  }
+
+  return {
+    id: responsesData.id || `chatcmpl-${Date.now()}`,
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model: responsesData.model || '',
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: 'assistant',
+          content: outputText,
+          // 🚀 Include reasoning metadata if available
+          ...(responsesData.reasoning && {
+            reasoning: {
+              effort: responsesData.reasoning.effort,
+              summary: responsesData.reasoning.summary,
+            },
+          }),
+        },
+        finish_reason: responsesData.status === 'completed' ? 'stop' : 'length',
+      },
+    ],
+    usage: {
+      prompt_tokens: usage.input_tokens || 0,
+      completion_tokens: usage.output_tokens || 0,
+      total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+      // 🔧 GPT-5 Enhanced Usage Details
+      prompt_tokens_details: {
+        cached_tokens: usage.input_tokens_details?.cached_tokens || 0,
+      },
+      completion_tokens_details: {
+        reasoning_tokens: usage.output_tokens_details?.reasoning_tokens || 0,
+      },
+    },
+  }
+}
+
+/**
+ * Enhanced getCompletionWithProfile that supports GPT-5 Responses API
+ * 🔥 Optimized for both official OpenAI and third-party GPT-5 providers
+ */
+async function getGPT5CompletionWithProfile(
+  modelProfile: any,
+  opts: OpenAI.ChatCompletionCreateParams,
+  attempt: number = 0,
+  maxAttempts: number = 10,
+  signal?: AbortSignal,
+): Promise<OpenAI.ChatCompletion | AsyncIterable<OpenAI.ChatCompletionChunk>> {
+  const features = getModelFeatures(opts.model)
+  const isOfficialOpenAI = !modelProfile.baseURL || 
+    modelProfile.baseURL.includes('api.openai.com')
+
+  // 🚀 Try Responses API for official OpenAI non-streaming requests
+  if (features.supportsResponsesAPI && !opts.stream && isOfficialOpenAI) {
+    try {
+      debugLogger.api('ATTEMPTING_GPT5_RESPONSES_API', {
+        model: opts.model,
+        baseURL: modelProfile.baseURL || 'official',
+        provider: modelProfile.provider,
+        stream: opts.stream,
+        requestId: getCurrentRequest()?.id,
+      })
+      
+      const result = await callGPT5ResponsesAPI(modelProfile, opts, signal)
+      
+      debugLogger.api('GPT5_RESPONSES_API_SUCCESS', {
+        model: opts.model,
+        baseURL: modelProfile.baseURL || 'official',
+        requestId: getCurrentRequest()?.id,
+      })
+      
+      return result
+    } catch (error) {
+      debugLogger.api('GPT5_RESPONSES_API_FALLBACK', {
+        model: opts.model,
+        error: error.message,
+        baseURL: modelProfile.baseURL || 'official',
+        requestId: getCurrentRequest()?.id,
+      })
+      
+      console.warn(
+        `🔄 GPT-5 Responses API failed, falling back to Chat Completions: ${error.message}`
+      )
+      // Fall through to Chat Completions API
+    }
+  } 
+  
+  // 🌐 Handle third-party GPT-5 providers with enhanced compatibility
+  else if (!isOfficialOpenAI) {
+    debugLogger.api('GPT5_THIRD_PARTY_PROVIDER', {
+      model: opts.model,
+      baseURL: modelProfile.baseURL,
+      provider: modelProfile.provider,
+      supportsResponsesAPI: features.supportsResponsesAPI,
+      requestId: getCurrentRequest()?.id,
+    })
+    
+    // 🔧 Apply enhanced parameter optimization for third-party providers
+    console.log(`🌐 Using GPT-5 via third-party provider: ${modelProfile.provider} (${modelProfile.baseURL})`)
+    
+    // Some third-party providers may need additional parameter adjustments
+    if (modelProfile.provider === 'azure') {
+      // Azure OpenAI specific adjustments
+      delete opts.reasoning_effort // Azure may not support this yet
+    } else if (modelProfile.provider === 'custom-openai') {
+      // Generic OpenAI-compatible provider optimizations
+      console.log(`🔧 Applying OpenAI-compatible optimizations for custom provider`)
+    }
+  }
+  
+  // 📡 Handle streaming requests (Responses API doesn't support streaming yet)
+  else if (opts.stream) {
+    debugLogger.api('GPT5_STREAMING_MODE', {
+      model: opts.model,
+      baseURL: modelProfile.baseURL || 'official',
+      reason: 'responses_api_no_streaming',
+      requestId: getCurrentRequest()?.id,
+    })
+    
+    console.log(`🔄 Using Chat Completions for streaming (Responses API streaming not available)`)
+  }
+
+  // 🔧 Enhanced Chat Completions fallback with GPT-5 optimizations
+  debugLogger.api('USING_CHAT_COMPLETIONS_FOR_GPT5', {
+    model: opts.model,
+    baseURL: modelProfile.baseURL || 'official',
+    provider: modelProfile.provider,
+    reason: isOfficialOpenAI ? 'streaming_or_fallback' : 'third_party_provider',
+    requestId: getCurrentRequest()?.id,
+  })
+
+  return await getCompletionWithProfile(
+    modelProfile,
+    opts,
+    attempt,
+    maxAttempts,
+    signal,
+  )
+}
+
+/**
+ * Fetch available models from custom OpenAI-compatible API
+ */
+export async function fetchCustomModels(
+  baseURL: string,
+  apiKey: string,
+): Promise<any[]> {
+  try {
+    // Check if baseURL already contains version number (e.g., v1, v2, etc.)
+    const hasVersionNumber = /\/v\d+/.test(baseURL)
+    const cleanBaseURL = baseURL.replace(/\/+$/, '')
+    const modelsURL = hasVersionNumber
+      ? `${cleanBaseURL}/models`
+      : `${cleanBaseURL}/v1/models`
+
+    const response = await fetch(modelsURL, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+    })
+
+    if (!response.ok) {
+      // Provide user-friendly error messages based on status code
+      if (response.status === 401) {
+        throw new Error(
+          'Invalid API key. Please check your API key and try again.',
+        )
+      } else if (response.status === 403) {
+        throw new Error(
+          'API key does not have permission to access models. Please check your API key permissions.',
+        )
+      } else if (response.status === 404) {
+        throw new Error(
+          'API endpoint not found. Please check if the base URL is correct and supports the /models endpoint.',
+        )
+      } else if (response.status === 429) {
+        throw new Error(
+          'Too many requests. Please wait a moment and try again.',
+        )
+      } else if (response.status >= 500) {
+        throw new Error(
+          'API service is temporarily unavailable. Please try again later.',
+        )
+      } else {
+        throw new Error(
+          `Unable to connect to API (${response.status}). Please check your base URL, API key, and internet connection.`,
+        )
+      }
+    }
+
+    const data = await response.json()
+
+    // Validate response format and extract models array
+    let models = []
+
+    if (data && data.data && Array.isArray(data.data)) {
+      // Standard OpenAI format: { data: [...] }
+      models = data.data
+    } else if (Array.isArray(data)) {
+      // Direct array format
+      models = data
+    } else if (data && data.models && Array.isArray(data.models)) {
+      // Alternative format: { models: [...] }
+      models = data.models
+    } else {
+      throw new Error(
+        'API returned unexpected response format. Expected an array of models or an object with a "data" or "models" array.',
+      )
+    }
+
+    // Ensure we have an array and validate it contains model objects
+    if (!Array.isArray(models)) {
+      throw new Error('API response format error: models data is not an array.')
+    }
+
+    return models
+  } catch (error) {
+    // If it's already our custom error, pass it through
+    if (
+      error instanceof Error &&
+      (error.message.includes('API key') ||
+        error.message.includes('API endpoint') ||
+        error.message.includes('API service') ||
+        error.message.includes('response format'))
+    ) {
+      throw error
+    }
+
+    // For network errors or other issues
+    console.error('Failed to fetch custom API models:', error)
+
+    // Check if it's a network error
+    if (error instanceof Error && error.message.includes('fetch')) {
+      throw new Error(
+        'Unable to connect to the API. Please check the base URL and your internet connection.',
+      )
+    }
+
+    throw new Error(
+      'Failed to fetch models from custom API. Please check your configuration and try again.',
+    )
+  }
+}