@shareai-lab/kode 1.2.0 → 2.0.2

package/dist/{services/openai.js → chunk-ZQU3TXLC.js}

@@ -1,9 +1,21 @@
-import { getGlobalConfig } from "../utils/config.js";
+import { createRequire as __kodeCreateRequire } from "node:module";
+const require = __kodeCreateRequire(import.meta.url);
+import {
+  getSessionState,
+  setSessionState
+} from "./chunk-E6YNABER.js";
+import {
+  getGlobalConfig
+} from "./chunk-AIMIPK4B.js";
+import {
+  debug,
+  getCurrentRequest,
+  logAPIError
+} from "./chunk-QYFKRZQC.js";
+
+// src/services/ai/openai.ts
 import { ProxyAgent, fetch } from "undici";
-import { setSessionState, getSessionState } from "../utils/sessionState.js";
-import { logEvent } from "../services/statsig.js";
-import { debug as debugLogger, getCurrentRequest, logAPIError } from "../utils/debugLogger.js";
-const RETRY_CONFIG = {
+var RETRY_CONFIG = {
   BASE_DELAY_MS: 1e3,
   MAX_DELAY_MS: 32e3,
   MAX_SERVER_DELAY_MS: 6e4,
@@ -38,15 +50,6 @@ function abortableDelay(delayMs, signal) {
     }
   });
 }
-var ModelErrorType = /* @__PURE__ */ ((ModelErrorType2) => {
-  ModelErrorType2["MaxLength"] = "1024";
-  ModelErrorType2["MaxCompletionTokens"] = "max_completion_tokens";
-  ModelErrorType2["TemperatureRestriction"] = "temperature_restriction";
-  ModelErrorType2["StreamOptions"] = "stream_options";
-  ModelErrorType2["Citations"] = "citations";
-  ModelErrorType2["RateLimit"] = "rate_limit";
-  return ModelErrorType2;
-})(ModelErrorType || {});
 function getModelErrorKey(baseURL, model, type) {
   return `${baseURL}:${model}:${type}`;
 }
@@ -58,20 +61,18 @@ function setModelError(baseURL, model, type, error) {
     [getModelErrorKey(baseURL, model, type)]: error
   });
 }
-const GPT5_ERROR_HANDLERS = [
+var GPT5_ERROR_HANDLERS = [
   {
     type: "max_completion_tokens" /* 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")
-      );
+      return lowerMsg.includes("unsupported parameter: 'max_tokens'") && lowerMsg.includes("'max_completion_tokens'") || 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") || lowerMsg.includes("invalid parameter") && lowerMsg.includes("max_tokens") || lowerMsg.includes("parameter error") && lowerMsg.includes("max_tokens");
     },
     fix: async (opts) => {
-      console.log(`\u{1F527} GPT-5 Fix: Converting max_tokens (${opts.max_tokens}) to max_completion_tokens`);
+      debug.api("GPT5_FIX_MAX_TOKENS", {
+        from: opts.max_tokens,
+        to: opts.max_tokens
+      });
       if ("max_tokens" in opts) {
         opts.max_completion_tokens = opts.max_tokens;
         delete opts.max_tokens;
@@ -85,13 +86,15 @@ const GPT5_ERROR_HANDLERS = [
       return lowerMsg.includes("temperature") && (lowerMsg.includes("only supports") || lowerMsg.includes("must be 1") || lowerMsg.includes("invalid temperature"));
     },
     fix: async (opts) => {
-      console.log(`\u{1F527} GPT-5 Fix: Adjusting temperature from ${opts.temperature} to 1`);
+      debug.api("GPT5_FIX_TEMPERATURE", {
+        from: opts.temperature,
+        to: 1
+      });
       opts.temperature = 1;
     }
   }
-  // Add more GPT-5 specific handlers as needed
 ];
-const ERROR_HANDLERS = [
+var ERROR_HANDLERS = [
   {
     type: "1024" /* MaxLength */,
     detect: (errMsg) => errMsg.includes("Expected a string with maximum length 1024"),
@@ -108,12 +111,6 @@ const ERROR_HANDLERS = [
             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;
       }
@@ -180,19 +177,12 @@ ${description}
     }
   }
 ];
-function isRateLimitError(errMsg) {
-  if (!errMsg) return false;
-  const lowerMsg = errMsg.toLowerCase();
-  return lowerMsg.includes("rate limit") || lowerMsg.includes("too many requests") || lowerMsg.includes("429");
-}
-const MODEL_FEATURES = {
-  // OpenAI thinking models
+var MODEL_FEATURES = {
   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,
@@ -220,7 +210,6 @@ const MODEL_FEATURES = {
   "gpt-5-chat-latest": {
     usesMaxCompletionTokens: true,
     supportsResponsesAPI: false,
-    // Uses Chat Completions only
     requiresTemperatureOne: true,
     supportsVerbosityControl: true
   }
@@ -257,15 +246,20 @@ function applyModelSpecificTransformations(opts) {
   const isGPT5 = opts.model.toLowerCase().includes("gpt-5");
   if (isGPT5 || features.usesMaxCompletionTokens) {
     if ("max_tokens" in opts && !("max_completion_tokens" in opts)) {
-      console.log(`\u{1F527} Transforming max_tokens (${opts.max_tokens}) to max_completion_tokens for ${opts.model}`);
+      debug.api("OPENAI_TRANSFORM_MAX_TOKENS", {
+        model: opts.model,
+        from: opts.max_tokens
+      });
       opts.max_completion_tokens = opts.max_tokens;
       delete opts.max_tokens;
     }
     if (features.requiresTemperatureOne && "temperature" in opts) {
       if (opts.temperature !== 1 && opts.temperature !== void 0) {
-        console.log(
-          `\u{1F527} GPT-5 temperature constraint: Adjusting temperature from ${opts.temperature} to 1 for ${opts.model}`
-        );
+        debug.api("OPENAI_TRANSFORM_TEMPERATURE", {
+          model: opts.model,
+          from: opts.temperature,
+          to: 1
+        });
         opts.temperature = 1;
       }
     }
@@ -311,22 +305,27 @@ async function tryWithEndpointFallback(baseURL, opts, headers, provider, proxy,
         body: JSON.stringify(opts.stream ? { ...opts, stream: true } : opts),
         dispatcher: proxy,
         signal
-        // 🔧 Connect AbortSignal to fetch call
       });
       if (response.ok) {
         return { response, endpoint };
       }
       if (response.status === 404 && endpointsToTry.length > 1) {
-        console.log(
-          `Endpoint ${endpoint} returned 404, trying next endpoint...`
-        );
+        debug.api("OPENAI_ENDPOINT_FALLBACK", {
+          endpoint,
+          status: 404,
+          reason: "not_found"
+        });
         continue;
       }
       return { response, endpoint };
     } catch (error) {
       lastError = error;
       if (endpointsToTry.indexOf(endpoint) < endpointsToTry.length - 1) {
-        console.log(`Network error on ${endpoint}, trying next endpoint...`);
+        debug.api("OPENAI_ENDPOINT_FALLBACK", {
+          endpoint,
+          reason: "network_error",
+          error: error instanceof Error ? error.message : String(error)
+        });
         continue;
       }
     }
@@ -353,7 +352,7 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
   }
   applyModelSpecificTransformations(opts);
   await applyModelErrorFixes(opts, baseURL || "");
-  debugLogger.api("OPENAI_API_CALL_START", {
+  debug.api("OPENAI_API_CALL_START", {
     endpoint: baseURL || "DEFAULT_OPENAI",
     model: opts.model,
     provider,
@@ -399,6 +398,7 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         "siliconflow",
         "qwen",
         "glm",
+        "glm-coding",
         "baidu-qianfan",
         "openai",
         "mistral",
@@ -416,7 +416,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
           provider,
           proxy,
           signal
-          // 🔧 Pass AbortSignal to endpoint fallback
         );
         response2 = result.response;
         usedEndpoint2 = result.endpoint;
@@ -427,7 +426,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
           body: JSON.stringify({ ...opts, stream: true }),
           dispatcher: proxy,
           signal
-          // 🔧 CRITICAL FIX: Connect AbortSignal to fetch call
         });
         usedEndpoint2 = endpoint;
       }
@@ -445,10 +443,23 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
           const handlers = isGPT5 ? [...GPT5_ERROR_HANDLERS, ...ERROR_HANDLERS] : ERROR_HANDLERS;
           for (const handler of handlers) {
             if (handler.detect(errorMessage)) {
-              console.log(`\u{1F527} Detected ${handler.type} error for ${opts.model}: ${errorMessage}`);
-              setModelError(baseURL || "", opts.model, handler.type, errorMessage);
+              debug.api("OPENAI_MODEL_ERROR_DETECTED", {
+                model: opts.model,
+                type: handler.type,
+                errorMessage,
+                status: response2.status
+              });
+              setModelError(
+                baseURL || "",
+                opts.model,
+                handler.type,
+                errorMessage
+              );
               await handler.fix(opts);
-              console.log(`\u{1F527} Applied fix for ${handler.type}, retrying...`);
+              debug.api("OPENAI_MODEL_ERROR_FIXED", {
+                model: opts.model,
+                type: handler.type
+              });
               return getCompletionWithProfile(
                 modelProfile,
                 opts,
@@ -458,7 +469,11 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
               );
             }
           }
-          console.log(`\u26A0\uFE0F  Unhandled API error (${response2.status}): ${errorMessage}`);
+          debug.warn("OPENAI_API_ERROR_UNHANDLED", {
+            model: opts.model,
+            status: response2.status,
+            errorMessage
+          });
           logAPIError({
             model: opts.model,
             endpoint: `${baseURL}${endpoint}`,
@@ -469,7 +484,11 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
             provider
           });
         } catch (parseError) {
-          console.log(`\u26A0\uFE0F  Could not parse error response (${response2.status})`);
+          debug.warn("OPENAI_API_ERROR_PARSE_FAILED", {
+            model: opts.model,
+            status: response2.status,
+            error: parseError instanceof Error ? parseError.message : String(parseError)
+          });
           logAPIError({
             model: opts.model,
             endpoint: `${baseURL}${endpoint}`,
@@ -481,9 +500,13 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
           });
         }
         const delayMs = getRetryDelay(attempt);
-        console.log(
-          `  \u23BF  API error (${response2.status}), retrying in ${Math.round(delayMs / 1e3)}s... (attempt ${attempt + 1}/${maxAttempts})`
-        );
+        debug.warn("OPENAI_API_RETRY", {
+          model: opts.model,
+          status: response2.status,
+          attempt: attempt + 1,
+          maxAttempts,
+          delayMs
+        });
         try {
           await abortableDelay(delayMs, signal);
         } catch (error) {
@@ -498,7 +521,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
           attempt + 1,
           maxAttempts,
           signal
-          // 🔧 Pass AbortSignal to recursive call
         );
       }
       const stream = createStreamProcessor(response2.body, signal);
@@ -528,7 +550,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         provider,
         proxy,
         signal
-        // 🔧 Pass AbortSignal to endpoint fallback
       );
       response = result.response;
       usedEndpoint = result.endpoint;
@@ -539,7 +560,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         body: JSON.stringify(opts),
         dispatcher: proxy,
         signal
-        // 🔧 CRITICAL FIX: Connect AbortSignal to non-streaming fetch call
       });
       usedEndpoint = endpoint;
     }
@@ -557,10 +577,18 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         const handlers = isGPT5 ? [...GPT5_ERROR_HANDLERS, ...ERROR_HANDLERS] : ERROR_HANDLERS;
         for (const handler of handlers) {
           if (handler.detect(errorMessage)) {
-            console.log(`\u{1F527} Detected ${handler.type} error for ${opts.model}: ${errorMessage}`);
+            debug.api("OPENAI_MODEL_ERROR_DETECTED", {
+              model: opts.model,
+              type: handler.type,
+              errorMessage,
+              status: response.status
+            });
             setModelError(baseURL || "", opts.model, handler.type, errorMessage);
             await handler.fix(opts);
-            console.log(`\u{1F527} Applied fix for ${handler.type}, retrying...`);
+            debug.api("OPENAI_MODEL_ERROR_FIXED", {
+              model: opts.model,
+              type: handler.type
+            });
             return getCompletionWithProfile(
               modelProfile,
               opts,
@@ -570,14 +598,26 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
             );
           }
         }
-        console.log(`\u26A0\uFE0F  Unhandled API error (${response.status}): ${errorMessage}`);
+        debug.warn("OPENAI_API_ERROR_UNHANDLED", {
+          model: opts.model,
+          status: response.status,
+          errorMessage
+        });
       } catch (parseError) {
-        console.log(`\u26A0\uFE0F  Could not parse error response (${response.status})`);
+        debug.warn("OPENAI_API_ERROR_PARSE_FAILED", {
+          model: opts.model,
+          status: response.status,
+          error: parseError instanceof Error ? parseError.message : String(parseError)
+        });
       }
       const delayMs = getRetryDelay(attempt);
-      console.log(
-        `  \u23BF  API error (${response.status}), retrying in ${Math.round(delayMs / 1e3)}s... (attempt ${attempt + 1}/${maxAttempts})`
-      );
+      debug.warn("OPENAI_API_RETRY", {
+        model: opts.model,
+        status: response.status,
+        attempt: attempt + 1,
+        maxAttempts,
+        delayMs
+      });
       try {
         await abortableDelay(delayMs, signal);
       } catch (error) {
@@ -592,7 +632,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         attempt + 1,
         maxAttempts,
         signal
-        // 🔧 Pass AbortSignal to recursive call
       );
     }
     const responseData = await response.json();
@@ -606,9 +645,13 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         throw new Error("Request cancelled by user");
       }
       const delayMs = getRetryDelay(attempt);
-      console.log(
-        `  \u23BF  Network error, retrying in ${Math.round(delayMs / 1e3)}s... (attempt ${attempt + 1}/${maxAttempts})`
-      );
+      debug.warn("OPENAI_NETWORK_RETRY", {
+        model: opts.model,
+        attempt: attempt + 1,
+        maxAttempts,
+        delayMs,
+        error: error instanceof Error ? error.message : String(error)
+      });
       try {
         await abortableDelay(delayMs, signal);
       } catch (error2) {
@@ -623,7 +666,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         attempt + 1,
         maxAttempts,
         signal
-        // 🔧 Pass AbortSignal to recursive call
       );
     }
     throw error;
@@ -649,7 +691,9 @@ function createStreamProcessor(stream, signal) {
           if (signal?.aborted) {
             break;
           }
-          console.error("Error reading from stream:", e);
+          debug.warn("OPENAI_STREAM_READ_ERROR", {
+            error: e instanceof Error ? e.message : String(e)
+          });
           break;
         }
         const { done, value } = readResult;
@@ -672,7 +716,10 @@ function createStreamProcessor(stream, signal) {
               const parsed = JSON.parse(data);
               yield parsed;
             } catch (e) {
-              console.error("Error parsing JSON:", data, e);
+              debug.warn("OPENAI_STREAM_JSON_PARSE_ERROR", {
+                data,
+                error: e instanceof Error ? e.message : String(e)
+              });
             }
           }
           lineEnd = buffer.indexOf("\n");
@@ -688,18 +735,25 @@ function createStreamProcessor(stream, signal) {
               const parsed = JSON.parse(data);
               yield parsed;
             } catch (e) {
-              console.error("Error parsing final JSON:", data, e);
+              debug.warn("OPENAI_STREAM_FINAL_JSON_PARSE_ERROR", {
+                data,
+                error: e instanceof Error ? e.message : String(e)
+              });
             }
           }
         }
       }
     } catch (e) {
-      console.error("Unexpected error in stream processing:", e);
+      debug.warn("OPENAI_STREAM_UNEXPECTED_ERROR", {
+        error: e instanceof Error ? e.message : String(e)
+      });
     } finally {
       try {
         reader.releaseLock();
       } catch (e) {
-        console.error("Error releasing reader lock:", e);
+        debug.warn("OPENAI_STREAM_RELEASE_LOCK_ERROR", {
+          error: e instanceof Error ? e.message : String(e)
+        });
       }
     }
   })();
@@ -707,7 +761,7 @@ function createStreamProcessor(stream, signal) {
 function streamCompletion(stream, signal) {
   return createStreamProcessor(stream, signal);
 }
-async function callGPT5ResponsesAPI(modelProfile, opts, signal) {
+async function callGPT5ResponsesAPI(modelProfile, request, signal) {
   const baseURL = modelProfile?.baseURL || "https://api.openai.com/v1";
   const apiKey = modelProfile?.apiKey;
   const proxy = getGlobalConfig().proxy ? new ProxyAgent(getGlobalConfig().proxy) : void 0;
@@ -715,59 +769,7 @@ async function callGPT5ResponsesAPI(modelProfile, opts, signal) {
     "Content-Type": "application/json",
     Authorization: `Bearer ${apiKey}`
   };
-  const responsesParams = {
-    model: opts.model,
-    input: opts.messages
-    // Responses API uses 'input' instead of 'messages'
-  };
-  if (opts.max_completion_tokens) {
-    responsesParams.max_completion_tokens = opts.max_completion_tokens;
-  } else if (opts.max_tokens) {
-    responsesParams.max_completion_tokens = opts.max_tokens;
-  }
-  if (opts.temperature === 1) {
-    responsesParams.temperature = 1;
-  }
-  const reasoningEffort = opts.reasoning_effort || "medium";
-  responsesParams.reasoning = {
-    effort: reasoningEffort,
-    // 🚀 Enable reasoning summaries for transparency in coding tasks
-    generate_summary: true
-  };
-  if (opts.tools && opts.tools.length > 0) {
-    responsesParams.tools = opts.tools;
-    if (opts.tool_choice) {
-      responsesParams.tool_choice = opts.tool_choice;
-    }
-  }
-  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;
-  }
-  const features = getModelFeatures(opts.model);
-  if (features.supportsVerbosityControl) {
-    responsesParams.text = {
-      verbosity: "high"
-    };
-  }
-  if (opts.model.startsWith("gpt-5")) {
-    if (!responsesParams.reasoning) {
-      responsesParams.reasoning = {
-        effort: "medium"
-        // Balanced for most coding tasks
-      };
-    }
-    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`;
-    }
-  }
+  const responsesParams = request;
   try {
     const response = await fetch(`${baseURL}/responses`, {
       method: "POST",
@@ -777,10 +779,12 @@ async function callGPT5ResponsesAPI(modelProfile, opts, signal) {
       signal
     });
     if (!response.ok) {
-      throw new Error(`GPT-5 Responses API error: ${response.status} ${response.statusText}`);
+      const errorText = await response.text();
+      throw new Error(
+        `GPT-5 Responses API error: ${response.status} ${response.statusText} - ${errorText}`
+      );
     }
-    const responseData = await response.json();
-    return convertResponsesAPIToChatCompletion(responseData);
+    return response;
   } catch (error) {
     if (signal?.aborted) {
       throw new Error("Request cancelled by user");
@@ -788,116 +792,43 @@ async function callGPT5ResponsesAPI(modelProfile, opts, signal) {
     throw error;
   }
 }
-function convertResponsesAPIToChatCompletion(responsesData) {
-  let outputText = responsesData.output_text || "";
-  const usage = responsesData.usage || {};
-  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 = `**\u{1F9E0} Reasoning Process:**
-${reasoningSummary}
-
-**\u{1F4DD} Response:**
-${mainContent}`;
-      } else {
-        outputText = mainContent;
-      }
-    }
-  }
-  return {
-    id: responsesData.id || `chatcmpl-${Date.now()}`,
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1e3),
-    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
-      }
-    }
-  };
-}
 async function getGPT5CompletionWithProfile(modelProfile, opts, attempt = 0, maxAttempts = 10, signal) {
   const features = getModelFeatures(opts.model);
   const isOfficialOpenAI = !modelProfile.baseURL || modelProfile.baseURL.includes("api.openai.com");
-  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(
-        `\u{1F504} GPT-5 Responses API failed, falling back to Chat Completions: ${error.message}`
-      );
-    }
-  } else if (!isOfficialOpenAI) {
-    debugLogger.api("GPT5_THIRD_PARTY_PROVIDER", {
+  if (!isOfficialOpenAI) {
+    debug.api("GPT5_THIRD_PARTY_PROVIDER", {
       model: opts.model,
       baseURL: modelProfile.baseURL,
       provider: modelProfile.provider,
       supportsResponsesAPI: features.supportsResponsesAPI,
       requestId: getCurrentRequest()?.id
     });
-    console.log(`\u{1F310} Using GPT-5 via third-party provider: ${modelProfile.provider} (${modelProfile.baseURL})`);
+    debug.api("GPT5_PROVIDER_THIRD_PARTY_NOTICE", {
+      model: opts.model,
+      provider: modelProfile.provider,
+      baseURL: modelProfile.baseURL
+    });
     if (modelProfile.provider === "azure") {
       delete opts.reasoning_effort;
     } else if (modelProfile.provider === "custom-openai") {
-      console.log(`\u{1F527} Applying OpenAI-compatible optimizations for custom provider`);
+      debug.api("GPT5_CUSTOM_PROVIDER_OPTIMIZATIONS", {
+        model: opts.model,
+        provider: modelProfile.provider
+      });
     }
   } else if (opts.stream) {
-    debugLogger.api("GPT5_STREAMING_MODE", {
+    debug.api("GPT5_STREAMING_MODE", {
       model: opts.model,
       baseURL: modelProfile.baseURL || "official",
       reason: "responses_api_no_streaming",
       requestId: getCurrentRequest()?.id
     });
-    console.log(`\u{1F504} Using Chat Completions for streaming (Responses API streaming not available)`);
+    debug.api("GPT5_STREAMING_FALLBACK_TO_CHAT_COMPLETIONS", {
+      model: opts.model,
+      reason: "responses_api_no_streaming"
+    });
   }
-  debugLogger.api("USING_CHAT_COMPLETIONS_FOR_GPT5", {
+  debug.api("USING_CHAT_COMPLETIONS_FOR_GPT5", {
     model: opts.model,
     baseURL: modelProfile.baseURL || "official",
     provider: modelProfile.provider,
@@ -978,7 +909,10 @@ async function fetchCustomModels(baseURL, apiKey) {
     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;
     }
-    console.error("Failed to fetch custom API models:", error);
+    debug.warn("CUSTOM_API_MODELS_FETCH_FAILED", {
+      baseURL,
+      error: error instanceof Error ? error.message : String(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."
@@ -989,14 +923,14 @@ async function fetchCustomModels(baseURL, apiKey) {
     );
   }
 }
+
 export {
+  getModelFeatures,
   applyModelSpecificTransformations,
-  callGPT5ResponsesAPI,
-  createStreamProcessor,
-  fetchCustomModels,
   getCompletionWithProfile,
+  createStreamProcessor,
+  streamCompletion,
+  callGPT5ResponsesAPI,
   getGPT5CompletionWithProfile,
-  getModelFeatures,
-  streamCompletion
+  fetchCustomModels
 };
-//# sourceMappingURL=openai.js.map