@within-7/minto 0.1.5 → 0.1.6

package/dist/services/openai.js

@@ -1,41 +1,26 @@
 import { getGlobalConfig } from "../utils/config.js";
 import { ProxyAgent, fetch } from "undici";
 import { setSessionState, getSessionState } from "../utils/sessionState.js";
-import { debug as debugLogger, getCurrentRequest, logAPIError } from "../utils/debugLogger.js";
+import {
+  debug as debugLogger,
+  getCurrentRequest,
+  logAPIError
+} from "../utils/debugLogger.js";
+import { logError } from "../utils/log.js";
+import { abortableDelay, DEFAULT_RETRY_CONFIG } from "../utils/async.js";
 const RETRY_CONFIG = {
-  BASE_DELAY_MS: 1e3,
-  MAX_DELAY_MS: 32e3,
-  MAX_SERVER_DELAY_MS: 6e4,
-  JITTER_FACTOR: 0.1
+  ...DEFAULT_RETRY_CONFIG
 };
 function getRetryDelay(attempt, retryAfter) {
   if (retryAfter) {
     const retryAfterMs = parseInt(retryAfter) * 1e3;
     if (!isNaN(retryAfterMs) && retryAfterMs > 0) {
-      return Math.min(retryAfterMs, RETRY_CONFIG.MAX_SERVER_DELAY_MS);
+      return Math.min(retryAfterMs, RETRY_CONFIG.maxServerDelayMs);
     }
   }
-  const delay = RETRY_CONFIG.BASE_DELAY_MS * Math.pow(2, attempt - 1);
-  const jitter = Math.random() * RETRY_CONFIG.JITTER_FACTOR * delay;
-  return Math.min(delay + jitter, RETRY_CONFIG.MAX_DELAY_MS);
-}
-function abortableDelay(delayMs, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new Error("Request was aborted"));
-      return;
-    }
-    const timeoutId = setTimeout(() => {
-      resolve();
-    }, delayMs);
-    if (signal) {
-      const abortHandler = () => {
-        clearTimeout(timeoutId);
-        reject(new Error("Request was aborted"));
-      };
-      signal.addEventListener("abort", abortHandler, { once: true });
-    }
-  });
+  const delay = RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt - 1);
+  const jitter = Math.random() * RETRY_CONFIG.jitterFactor * delay;
+  return Math.min(delay + jitter, RETRY_CONFIG.maxDelayMs);
 }
 var ModelErrorType = /* @__PURE__ */ ((ModelErrorType2) => {
   ModelErrorType2["MaxLength"] = "1024";
@@ -70,7 +55,10 @@ const GPT5_ERROR_HANDLERS = [
       );
     },
     fix: async (opts) => {
-      console.log(`\u{1F527} GPT-5 Fix: Converting max_tokens (${opts.max_tokens}) to max_completion_tokens`);
+      debugLogger.info("GPT5_FIX", {
+        action: "convert_max_tokens",
+        from: opts.max_tokens
+      });
       if ("max_tokens" in opts) {
         opts.max_completion_tokens = opts.max_tokens;
         delete opts.max_tokens;
@@ -84,7 +72,11 @@ 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`);
+      debugLogger.info("GPT5_FIX", {
+        action: "adjust_temperature",
+        from: opts.temperature,
+        to: 1
+      });
       opts.temperature = 1;
     }
   }
@@ -173,11 +165,6 @@ ${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
   o1: { usesMaxCompletionTokens: true },
@@ -250,15 +237,22 @@ 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}`);
+      debugLogger.info("OPENAI_TRANSFORM", {
+        action: "max_tokens_to_completion",
+        model: opts.model,
+        value: 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}`
-        );
+        debugLogger.info("OPENAI_TRANSFORM", {
+          action: "temperature_constraint",
+          model: opts.model,
+          from: opts.temperature,
+          to: 1
+        });
         opts.temperature = 1;
       }
     }
@@ -310,16 +304,22 @@ async function tryWithEndpointFallback(baseURL, opts, headers, provider, proxy,
         return { response, endpoint };
       }
       if (response.status === 404 && endpointsToTry.length > 1) {
-        console.log(
-          `Endpoint ${endpoint} returned 404, trying next endpoint...`
-        );
+        debugLogger.info("OPENAI_ENDPOINT", {
+          status: 404,
+          endpoint,
+          action: "trying_next"
+        });
         continue;
       }
       return { response, endpoint };
     } catch (error) {
       lastError = error;
       if (endpointsToTry.indexOf(endpoint) < endpointsToTry.length - 1) {
-        console.log(`Network error on ${endpoint}, trying next endpoint...`);
+        debugLogger.warn("OPENAI_ENDPOINT", {
+          error: "network_error",
+          endpoint,
+          action: "trying_next"
+        });
         continue;
       }
     }
@@ -400,7 +400,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         "custom-openai"
       ].includes(provider);
       let response2;
-      let usedEndpoint2;
       if (isOpenAICompatible2 && provider !== "azure") {
         const result = await tryWithEndpointFallback(
           baseURL,
@@ -412,7 +411,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
           // 🔧 Pass AbortSignal to endpoint fallback
         );
         response2 = result.response;
-        usedEndpoint2 = result.endpoint;
       } else {
         response2 = await fetch(`${baseURL}${endpoint}`, {
           method: "POST",
@@ -422,7 +420,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
           signal
           // 🔧 CRITICAL FIX: Connect AbortSignal to fetch call
         });
-        usedEndpoint2 = endpoint;
       }
       if (!response2.ok) {
         if (signal?.aborted) {
@@ -438,10 +435,22 @@ 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);
+              debugLogger.info("OPENAI_ERROR_HANDLER", {
+                type: handler.type,
+                model: opts.model,
+                error: errorMessage
+              });
+              setModelError(
+                baseURL || "",
+                opts.model,
+                handler.type,
+                errorMessage
+              );
               await handler.fix(opts);
-              console.log(`\u{1F527} Applied fix for ${handler.type}, retrying...`);
+              debugLogger.info("OPENAI_ERROR_HANDLER", {
+                action: "fix_applied",
+                type: handler.type
+              });
               return getCompletionWithProfile(
                 modelProfile,
                 opts,
@@ -451,7 +460,10 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
               );
             }
           }
-          console.log(`\u26A0\uFE0F  Unhandled API error (${response2.status}): ${errorMessage}`);
+          debugLogger.warn("OPENAI_UNHANDLED_ERROR", {
+            status: response2.status,
+            error: errorMessage
+          });
           logAPIError({
             model: opts.model,
             endpoint: `${baseURL}${endpoint}`,
@@ -462,7 +474,7 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
             provider
           });
         } catch (parseError) {
-          console.log(`\u26A0\uFE0F  Could not parse error response (${response2.status})`);
+          debugLogger.warn("OPENAI_PARSE_ERROR", { status: response2.status });
           logAPIError({
             model: opts.model,
             endpoint: `${baseURL}${endpoint}`,
@@ -512,7 +524,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
       "custom-openai"
     ].includes(provider);
     let response;
-    let usedEndpoint;
     if (isOpenAICompatible && provider !== "azure") {
       const result = await tryWithEndpointFallback(
         baseURL,
@@ -524,7 +535,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         // 🔧 Pass AbortSignal to endpoint fallback
       );
       response = result.response;
-      usedEndpoint = result.endpoint;
     } else {
       response = await fetch(`${baseURL}${endpoint}`, {
         method: "POST",
@@ -534,7 +544,6 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
         signal
         // 🔧 CRITICAL FIX: Connect AbortSignal to non-streaming fetch call
       });
-      usedEndpoint = endpoint;
     }
     if (!response.ok) {
       if (signal?.aborted) {
@@ -550,10 +559,17 @@ 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}`);
+            debugLogger.info("OPENAI_ERROR_HANDLER", {
+              type: handler.type,
+              model: opts.model,
+              error: errorMessage
+            });
             setModelError(baseURL || "", opts.model, handler.type, errorMessage);
             await handler.fix(opts);
-            console.log(`\u{1F527} Applied fix for ${handler.type}, retrying...`);
+            debugLogger.info("OPENAI_ERROR_HANDLER", {
+              action: "fix_applied",
+              type: handler.type
+            });
             return getCompletionWithProfile(
               modelProfile,
               opts,
@@ -563,9 +579,12 @@ async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAtte
             );
           }
         }
-        console.log(`\u26A0\uFE0F  Unhandled API error (${response.status}): ${errorMessage}`);
+        debugLogger.warn("OPENAI_UNHANDLED_ERROR", {
+          status: response.status,
+          error: errorMessage
+        });
       } catch (parseError) {
-        console.log(`\u26A0\uFE0F  Could not parse error response (${response.status})`);
+        debugLogger.warn("OPENAI_PARSE_ERROR", { status: response.status });
       }
       const delayMs = getRetryDelay(attempt);
       console.log(
@@ -642,7 +661,7 @@ function createStreamProcessor(stream, signal) {
           if (signal?.aborted) {
             break;
           }
-          console.error("Error reading from stream:", e);
+          logError(e);
           break;
         }
         const { done, value } = readResult;
@@ -665,7 +684,10 @@ function createStreamProcessor(stream, signal) {
               const parsed = JSON.parse(data);
               yield parsed;
             } catch (e) {
-              console.error("Error parsing JSON:", data, e);
+              debugLogger.warn("STREAM_PARSE_ERROR", {
+                data: data.substring(0, 100),
+                error: String(e)
+              });
             }
           }
           lineEnd = buffer.indexOf("\n");
@@ -681,18 +703,21 @@ function createStreamProcessor(stream, signal) {
               const parsed = JSON.parse(data);
               yield parsed;
             } catch (e) {
-              console.error("Error parsing final JSON:", data, e);
+              debugLogger.warn("STREAM_PARSE_ERROR", {
+                data: data.substring(0, 100),
+                error: String(e),
+                final: true
+              });
             }
           }
         }
       }
     } catch (e) {
-      console.error("Unexpected error in stream processing:", e);
+      logError(e);
     } finally {
       try {
         reader.releaseLock();
       } catch (e) {
-        console.error("Error releasing reader lock:", e);
       }
     }
   })();
@@ -770,7 +795,9 @@ async function callGPT5ResponsesAPI(modelProfile, opts, signal) {
       signal
     });
     if (!response.ok) {
-      throw new Error(`GPT-5 Responses API error: ${response.status} ${response.statusText}`);
+      throw new Error(
+        `GPT-5 Responses API error: ${response.status} ${response.statusText}`
+      );
     }
     const responseData = await response.json();
     return convertResponsesAPIToChatCompletion(responseData);
@@ -785,8 +812,12 @@ 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");
+    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");
@@ -863,9 +894,10 @@ async function getGPT5CompletionWithProfile(modelProfile, opts, attempt = 0, max
         baseURL: modelProfile.baseURL || "official",
         requestId: getCurrentRequest()?.id
       });
-      console.warn(
-        `\u{1F504} GPT-5 Responses API failed, falling back to Chat Completions: ${error.message}`
-      );
+      debugLogger.warn("GPT5_FALLBACK", {
+        reason: "responses_api_failed",
+        error: error.message
+      });
     }
   } else if (!isOfficialOpenAI) {
     debugLogger.api("GPT5_THIRD_PARTY_PROVIDER", {
@@ -875,11 +907,16 @@ async function getGPT5CompletionWithProfile(modelProfile, opts, attempt = 0, max
       supportsResponsesAPI: features.supportsResponsesAPI,
       requestId: getCurrentRequest()?.id
     });
-    console.log(`\u{1F310} Using GPT-5 via third-party provider: ${modelProfile.provider} (${modelProfile.baseURL})`);
+    debugLogger.info("GPT5_THIRD_PARTY", {
+      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`);
+      debugLogger.info("GPT5_CUSTOM_OPTIMIZATIONS", {
+        provider: "custom-openai"
+      });
     }
   } else if (opts.stream) {
     debugLogger.api("GPT5_STREAMING_MODE", {
@@ -888,7 +925,7 @@ async function getGPT5CompletionWithProfile(modelProfile, opts, attempt = 0, max
       reason: "responses_api_no_streaming",
       requestId: getCurrentRequest()?.id
     });
-    console.log(`\u{1F504} Using Chat Completions for streaming (Responses API streaming not available)`);
+    debugLogger.info("GPT5_STREAMING", { reason: "responses_api_no_streaming" });
   }
   debugLogger.api("USING_CHAT_COMPLETIONS_FOR_GPT5", {
     model: opts.model,
@@ -971,7 +1008,7 @@ 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);
+    logError(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."