@within-7/minto 0.4.2 → 0.4.3

package/dist/services/openai.js

@@ -1,1120 +0,0 @@
-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 { logError } from "../utils/log.js";
-import { setStreamingState } from "../utils/streamingState.js";
-import {
-  abortableDelay,
-  getRetryDelay as sharedGetRetryDelay
-} from "../utils/async.js";
-import {
-  UserFriendlyError
-} from "../utils/userFriendlyError.js";
-import { isOpenAICompatibleProvider } from "../constants/providers.js";
-import { getEffectiveCapabilities } from "../constants/providerRegistry.js";
-import { resolveApiKey } from "../utils/config.js";
-async function resolveModelApiKey(modelProfile) {
-  if (!modelProfile?.apiKey) return "";
-  return await resolveApiKey(modelProfile) ?? modelProfile.apiKey;
-}
-function getRetryDelay(attempt) {
-  return sharedGetRetryDelay(attempt);
-}
-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";
-  ModelErrorType2["UnsupportedParam"] = "unsupported_param";
-  return ModelErrorType2;
-})(ModelErrorType || {});
-function getModelErrorKey(baseURL, model, type) {
-  return `${baseURL}:${model}:${type}`;
-}
-function hasModelError(baseURL, model, type) {
-  return !!getSessionState("modelErrors")[getModelErrorKey(baseURL, model, type)];
-}
-function setModelError(baseURL, model, type, error) {
-  setSessionState("modelErrors", {
-    [getModelErrorKey(baseURL, model, type)]: error
-  });
-}
-const 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")
-      );
-    },
-    fix: async (opts) => {
-      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;
-      }
-    }
-  },
-  {
-    type: "temperature_restriction" /* 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) => {
-      debugLogger.info("GPT5_FIX", {
-        action: "adjust_temperature",
-        from: opts.temperature,
-        to: 1
-      });
-      opts.temperature = 1;
-    }
-  }
-  // Add more GPT-5 specific handlers as needed
-];
-const ERROR_HANDLERS = [
-  {
-    type: "1024" /* 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";
-          }
-        }
-        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}>
-${description}
-</${name}>
-
-`;
-        }
-        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: "max_completion_tokens" /* MaxCompletionTokens */,
-    detect: (errMsg) => errMsg.includes("Use 'max_completion_tokens'"),
-    fix: async (opts) => {
-      opts.max_completion_tokens = opts.max_tokens;
-      delete opts.max_tokens;
-    }
-  },
-  {
-    type: "stream_options" /* StreamOptions */,
-    detect: (errMsg) => errMsg.includes("stream_options"),
-    fix: async (opts) => {
-      delete opts.stream_options;
-    }
-  },
-  {
-    type: "unsupported_param" /* UnsupportedParam */,
-    detect: (errMsg) => {
-      const lower = errMsg.toLowerCase();
-      return lower.includes("unsupported") && lower.includes("reasoning_effort") || lower.includes("does not support") && lower.includes("reasoning_effort");
-    },
-    fix: async (opts) => {
-      debugLogger.info("OPENAI_FIX", {
-        action: "remove_reasoning_effort",
-        model: opts.model
-      });
-      delete opts.reasoning_effort;
-    }
-  },
-  {
-    type: "citations" /* 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) {
-            if (item && typeof item === "object") {
-              const itemObj = item;
-              if ("citations" in itemObj) {
-                delete itemObj.citations;
-              }
-            }
-          }
-        } else if (message.content && typeof message.content === "object") {
-          const contentObj = message.content;
-          if ("citations" in contentObj) {
-            delete contentObj.citations;
-          }
-        }
-      }
-    }
-  }
-];
-const MODEL_FEATURES = {
-  // 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
-  }
-};
-function getModelFeatures(modelName) {
-  if (!modelName || typeof modelName !== "string") {
-    return { usesMaxCompletionTokens: false };
-  }
-  if (MODEL_FEATURES[modelName]) {
-    return MODEL_FEATURES[modelName];
-  }
-  if (modelName.toLowerCase().includes("gpt-5")) {
-    return {
-      usesMaxCompletionTokens: true,
-      supportsResponsesAPI: true,
-      requiresTemperatureOne: true,
-      supportsVerbosityControl: true,
-      supportsCustomTools: true,
-      supportsAllowedTools: true
-    };
-  }
-  for (const [key, features] of Object.entries(MODEL_FEATURES)) {
-    if (modelName.includes(key)) {
-      return features;
-    }
-  }
-  return { usesMaxCompletionTokens: false };
-}
-function applyModelSpecificTransformations(opts) {
-  if (!opts.model || typeof opts.model !== "string") {
-    return;
-  }
-  const features = getModelFeatures(opts.model);
-  const isGPT5 = opts.model.toLowerCase().includes("gpt-5");
-  if (isGPT5 || features.usesMaxCompletionTokens) {
-    if ("max_tokens" in opts && !("max_completion_tokens" in opts)) {
-      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) {
-        debugLogger.info("OPENAI_TRANSFORM", {
-          action: "temperature_constraint",
-          model: opts.model,
-          from: opts.temperature,
-          to: 1
-        });
-        opts.temperature = 1;
-      }
-    }
-    if (isGPT5) {
-      delete opts.frequency_penalty;
-      delete opts.presence_penalty;
-      delete opts.logit_bias;
-      delete opts.user;
-      if (!opts.reasoning_effort && features.supportsVerbosityControl) {
-        opts.reasoning_effort = "medium";
-      }
-    }
-  } else {
-    if (features.usesMaxCompletionTokens && "max_tokens" in opts && !("max_completion_tokens" in opts)) {
-      opts.max_completion_tokens = opts.max_tokens;
-      delete opts.max_tokens;
-    }
-  }
-}
-function normalizeRequestParams(opts, provider) {
-  if (!opts.model || typeof opts.model !== "string") {
-    return;
-  }
-  const caps = getEffectiveCapabilities(provider, opts.model);
-  const correctField = caps.maxTokensField;
-  if (correctField === "max_completion_tokens") {
-    if ("max_tokens" in opts && !("max_completion_tokens" in opts)) {
-      opts.max_completion_tokens = opts.max_tokens;
-      delete opts.max_tokens;
-    }
-  } else if (correctField === "max_tokens") {
-    if ("max_completion_tokens" in opts && !("max_tokens" in opts)) {
-      opts.max_tokens = opts.max_completion_tokens;
-      delete opts.max_completion_tokens;
-    }
-  }
-  if (caps.temperatureRange === "omit") {
-    delete opts.temperature;
-  } else if ("temperature" in opts && opts.temperature !== void 0) {
-    const { min, max } = caps.temperatureRange;
-    opts.temperature = Math.max(min, Math.min(max, opts.temperature));
-  }
-  if (caps.supportsToolChoice === "auto-only" && opts.tool_choice && typeof opts.tool_choice === "object") {
-    opts.tool_choice = "auto";
-  } else if (caps.supportsToolChoice === false) {
-    delete opts.tool_choice;
-  }
-  if (caps.maxStopSequences !== null && opts.stop && Array.isArray(opts.stop) && opts.stop.length > caps.maxStopSequences) {
-    opts.stop = opts.stop.slice(0, caps.maxStopSequences);
-  }
-}
-async function applyModelErrorFixes(opts, baseURL) {
-  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;
-    }
-  }
-}
-const API_FETCH_TIMEOUT_MS = parseInt(
-  process.env.API_TIMEOUT_MS || String(120 * 1e3),
-  10
-);
-function withFetchTimeout(signal) {
-  const timeoutSignal = AbortSignal.timeout(API_FETCH_TIMEOUT_MS);
-  if (!signal) return timeoutSignal;
-  return AbortSignal.any([signal, timeoutSignal]);
-}
-async function tryWithEndpointFallback(baseURL, opts, headers, provider, proxy, signal) {
-  const endpointsToTry = [];
-  if (provider === "minimax") {
-    endpointsToTry.push("/text/chatcompletion_v2", "/chat/completions");
-  } else {
-    endpointsToTry.push("/chat/completions");
-  }
-  let lastError = null;
-  const fetchSignal = withFetchTimeout(signal);
-  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: fetchSignal
-      });
-      if (response.ok) {
-        return { response, endpoint };
-      }
-      if (response.status === 404 && endpointsToTry.length > 1) {
-        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) {
-        debugLogger.warn("OPENAI_ENDPOINT", {
-          error: "network_error",
-          endpoint,
-          action: "trying_next"
-        });
-        continue;
-      }
-    }
-  }
-  throw lastError || new Error("All endpoints failed");
-}
-async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAttempts = 5, signal) {
-  if (attempt >= maxAttempts) {
-    throw new Error("Max attempts reached");
-  }
-  const provider = modelProfile?.provider || "anthropic";
-  const baseURL = modelProfile?.baseURL;
-  const apiKey = await resolveModelApiKey(modelProfile);
-  const proxy = getGlobalConfig().proxy ? new ProxyAgent(getGlobalConfig().proxy) : void 0;
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    if (provider === "azure") {
-      headers["api-key"] = apiKey;
-    } else {
-      headers["Authorization"] = `Bearer ${apiKey}`;
-    }
-  }
-  applyModelSpecificTransformations(opts);
-  normalizeRequestParams(opts, provider);
-  await applyModelErrorFixes(opts, baseURL || "");
-  debugLogger.api("OPENAI_API_CALL_START", {
-    endpoint: baseURL || "DEFAULT_OPENAI",
-    model: opts.model,
-    provider,
-    apiKeyConfigured: !!apiKey,
-    apiKeyPrefix: apiKey ? apiKey.substring(0, 4) + "..." : null,
-    maxTokens: opts.max_tokens,
-    temperature: opts.temperature,
-    messageCount: opts.messages?.length || 0,
-    streamMode: opts.stream,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    modelProfileModelName: modelProfile?.modelName,
-    modelProfileName: modelProfile?.name
-  });
-  opts.messages = opts.messages.map((msg) => {
-    if (msg.role === "assistant" && Array.isArray(msg.content)) {
-      const filtered = msg.content.filter(
-        (block) => block.type !== "thinking" && block.type !== "redacted_thinking"
-      );
-      if (filtered.length !== msg.content.length) {
-        return {
-          ...msg,
-          content: filtered.length > 0 ? filtered : [{ type: "text", text: "" }]
-        };
-      }
-    }
-    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;
-  });
-  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) {
-      let response2;
-      if (isOpenAICompatibleProvider(provider) && provider !== "azure") {
-        const result = await tryWithEndpointFallback(
-          baseURL,
-          opts,
-          headers,
-          provider,
-          proxy,
-          signal
-          // 🔧 Pass AbortSignal to endpoint fallback
-        );
-        response2 = result.response;
-      } else {
-        response2 = await fetch(`${baseURL}${endpoint}`, {
-          method: "POST",
-          headers,
-          body: JSON.stringify({ ...opts, stream: true }),
-          dispatcher: proxy,
-          signal: withFetchTimeout(signal)
-        });
-      }
-      if (!response2.ok) {
-        if (signal?.aborted) {
-          throw new Error("Request cancelled by user");
-        }
-        try {
-          const errorData = await response2.json();
-          const hasError = (data) => {
-            return typeof data === "object" && data !== null;
-          };
-          const errorMessage = hasError(errorData) ? errorData.error?.message || errorData.message || `HTTP ${response2.status}` : `HTTP ${response2.status}`;
-          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)) {
-              debugLogger.info("OPENAI_ERROR_HANDLER", {
-                type: handler.type,
-                model: opts.model,
-                error: errorMessage
-              });
-              setModelError(
-                baseURL || "",
-                opts.model,
-                handler.type,
-                errorMessage
-              );
-              await handler.fix(opts);
-              debugLogger.info("OPENAI_ERROR_HANDLER", {
-                action: "fix_applied",
-                type: handler.type
-              });
-              return getCompletionWithProfile(
-                modelProfile,
-                opts,
-                attempt + 1,
-                maxAttempts,
-                signal
-              );
-            }
-          }
-          debugLogger.warn("OPENAI_UNHANDLED_ERROR", {
-            status: response2.status,
-            error: errorMessage
-          });
-          logAPIError({
-            model: opts.model,
-            endpoint: `${baseURL}${endpoint}`,
-            status: response2.status,
-            error: errorMessage,
-            request: opts,
-            response: errorData,
-            provider
-          });
-        } catch (parseError) {
-          debugLogger.warn("OPENAI_PARSE_ERROR", { status: response2.status });
-          logAPIError({
-            model: opts.model,
-            endpoint: `${baseURL}${endpoint}`,
-            status: response2.status,
-            error: `Could not parse error response: ${parseError.message}`,
-            request: opts,
-            response: { parseError: parseError.message },
-            provider
-          });
-        }
-        const delayMs = getRetryDelay(attempt);
-        setStreamingState({
-          phase: "retrying",
-          retryCount: attempt + 1,
-          maxRetries: maxAttempts,
-          errorName: `HTTP ${response2.status}`,
-          retryDelayMs: delayMs
-        });
-        debugLogger.warn("API_RETRY", {
-          status: response2.status,
-          delayMs,
-          attempt: attempt + 1,
-          maxAttempts
-        });
-        try {
-          await abortableDelay(delayMs, signal);
-        } catch (error) {
-          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(response2.body, signal);
-      return stream;
-    }
-    let response;
-    if (isOpenAICompatibleProvider(provider) && provider !== "azure") {
-      const result = await tryWithEndpointFallback(
-        baseURL,
-        opts,
-        headers,
-        provider,
-        proxy,
-        signal
-        // 🔧 Pass AbortSignal to endpoint fallback
-      );
-      response = result.response;
-    } else {
-      response = await fetch(`${baseURL}${endpoint}`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(opts),
-        dispatcher: proxy,
-        signal: withFetchTimeout(signal)
-      });
-    }
-    if (!response.ok) {
-      if (signal?.aborted) {
-        throw new Error("Request cancelled by user");
-      }
-      try {
-        const errorData = await response.json();
-        const hasError = (data) => {
-          return typeof data === "object" && data !== null;
-        };
-        const errorMessage = hasError(errorData) ? errorData.error?.message || errorData.message || `HTTP ${response.status}` : `HTTP ${response.status}`;
-        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)) {
-            debugLogger.info("OPENAI_ERROR_HANDLER", {
-              type: handler.type,
-              model: opts.model,
-              error: errorMessage
-            });
-            setModelError(baseURL || "", opts.model, handler.type, errorMessage);
-            await handler.fix(opts);
-            debugLogger.info("OPENAI_ERROR_HANDLER", {
-              action: "fix_applied",
-              type: handler.type
-            });
-            return getCompletionWithProfile(
-              modelProfile,
-              opts,
-              attempt + 1,
-              maxAttempts,
-              signal
-            );
-          }
-        }
-        debugLogger.warn("OPENAI_UNHANDLED_ERROR", {
-          status: response.status,
-          error: errorMessage
-        });
-      } catch (parseError) {
-        debugLogger.warn("OPENAI_PARSE_ERROR", { status: response.status });
-      }
-      const delayMs = getRetryDelay(attempt);
-      setStreamingState({
-        phase: "retrying",
-        retryCount: attempt + 1,
-        maxRetries: maxAttempts,
-        errorName: `HTTP ${response.status}`,
-        retryDelayMs: delayMs
-      });
-      debugLogger.warn("API_RETRY", {
-        status: response.status,
-        delayMs,
-        attempt: attempt + 1,
-        maxAttempts
-      });
-      try {
-        await abortableDelay(delayMs, signal);
-      } catch (error) {
-        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();
-    return responseData;
-  } catch (error) {
-    if (signal?.aborted) {
-      throw new Error("Request cancelled by user");
-    }
-    if (attempt < maxAttempts) {
-      if (signal?.aborted) {
-        throw new Error("Request cancelled by user");
-      }
-      const delayMs = getRetryDelay(attempt);
-      setStreamingState({
-        phase: "retrying",
-        retryCount: attempt + 1,
-        maxRetries: maxAttempts,
-        errorName: error instanceof Error ? error.message.slice(0, 30) : "network error",
-        retryDelayMs: delayMs
-      });
-      debugLogger.warn("API_RETRY", {
-        error: "network_error",
-        delayMs,
-        attempt: attempt + 1,
-        maxAttempts
-      });
-      try {
-        await abortableDelay(delayMs, signal);
-      } catch (error2) {
-        if (error2.message === "Request was aborted") {
-          throw new Error("Request cancelled by user");
-        }
-        throw error2;
-      }
-      return getCompletionWithProfile(
-        modelProfile,
-        opts,
-        attempt + 1,
-        maxAttempts,
-        signal
-        // 🔧 Pass AbortSignal to recursive call
-      );
-    }
-    throw new UserFriendlyError(error, {
-      operation: "API request",
-      model: opts.model,
-      endpoint: modelProfile.baseURL
-    });
-  }
-}
-const STREAM_IDLE_TIMEOUT_MS = parseInt(
-  process.env.STREAM_IDLE_TIMEOUT_MS || String(120 * 1e3),
-  10
-);
-function createStreamProcessor(stream, signal) {
-  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) {
-        if (signal?.aborted) {
-          break;
-        }
-        let readResult;
-        try {
-          readResult = await Promise.race([
-            reader.read(),
-            new Promise((_, reject) => {
-              const timer = setTimeout(
-                () => reject(
-                  new Error(
-                    `Stream idle timeout: no data received for ${STREAM_IDLE_TIMEOUT_MS / 1e3}s`
-                  )
-                ),
-                STREAM_IDLE_TIMEOUT_MS
-              );
-              signal?.addEventListener("abort", () => clearTimeout(timer), {
-                once: true
-              });
-            })
-          ]);
-        } catch (e) {
-          if (signal?.aborted) {
-            break;
-          }
-          logError(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);
-              yield parsed;
-            } catch (e) {
-              debugLogger.warn("STREAM_PARSE_ERROR", {
-                data: data.substring(0, 100),
-                error: String(e)
-              });
-            }
-          }
-          lineEnd = buffer.indexOf("\n");
-        }
-      }
-      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);
-              yield parsed;
-            } catch (e) {
-              debugLogger.warn("STREAM_PARSE_ERROR", {
-                data: data.substring(0, 100),
-                error: String(e),
-                final: true
-              });
-            }
-          }
-        }
-      }
-    } catch (e) {
-      logError(e);
-    } finally {
-      try {
-        reader.releaseLock();
-      } catch (e) {
-      }
-    }
-  })();
-}
-function streamCompletion(stream, signal) {
-  return createStreamProcessor(stream, signal);
-}
-async function callGPT5ResponsesAPI(modelProfile, opts, signal) {
-  const baseURL = modelProfile?.baseURL || "https://api.openai.com/v1";
-  const apiKey = await resolveModelApiKey(modelProfile);
-  const proxy = getGlobalConfig().proxy ? new ProxyAgent(getGlobalConfig().proxy) : void 0;
-  const headers = {
-    "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_output_tokens = opts.max_completion_tokens;
-  } else if (opts.max_tokens) {
-    responsesParams.max_output_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
-      };
-    }
-  }
-  try {
-    const response = await fetch(`${baseURL}/responses`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(responsesParams),
-      dispatcher: proxy,
-      signal
-    });
-    if (!response.ok) {
-      throw new Error(
-        `GPT-5 Responses API error: ${response.status} ${response.statusText}`
-      );
-    }
-    const responseData = await response.json();
-    return convertResponsesAPIToChatCompletion(responseData);
-  } catch (error) {
-    if (signal?.aborted) {
-      throw new Error("Request cancelled by user");
-    }
-    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 = 5, 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
-      });
-      debugLogger.warn("GPT5_FALLBACK", {
-        reason: "responses_api_failed",
-        error: error.message
-      });
-    }
-  } else if (!isOfficialOpenAI) {
-    debugLogger.api("GPT5_THIRD_PARTY_PROVIDER", {
-      model: opts.model,
-      baseURL: modelProfile.baseURL,
-      provider: modelProfile.provider,
-      supportsResponsesAPI: features.supportsResponsesAPI,
-      requestId: getCurrentRequest()?.id
-    });
-    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") {
-      debugLogger.info("GPT5_CUSTOM_OPTIMIZATIONS", {
-        provider: "custom-openai"
-      });
-    }
-  } else if (opts.stream) {
-    debugLogger.api("GPT5_STREAMING_MODE", {
-      model: opts.model,
-      baseURL: modelProfile.baseURL || "official",
-      reason: "responses_api_no_streaming",
-      requestId: getCurrentRequest()?.id
-    });
-    debugLogger.info("GPT5_STREAMING", { reason: "responses_api_no_streaming" });
-  }
-  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
-  );
-}
-async function fetchCustomModels(baseURL, apiKey) {
-  try {
-    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"
-      },
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!response.ok) {
-      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();
-    const hasDataArray = (obj) => {
-      return typeof obj === "object" && obj !== null && "data" in obj && Array.isArray(obj.data);
-    };
-    const hasModelsArray = (obj) => {
-      return typeof obj === "object" && obj !== null && "models" in obj && Array.isArray(obj.models);
-    };
-    let models = [];
-    if (hasDataArray(data)) {
-      models = data.data;
-    } else if (Array.isArray(data)) {
-      models = data;
-    } else if (hasModelsArray(data)) {
-      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.'
-      );
-    }
-    if (!Array.isArray(models)) {
-      throw new Error("API response format error: models data is not an array.");
-    }
-    return models;
-  } catch (error) {
-    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;
-    }
-    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."
-      );
-    }
-    throw new Error(
-      "Failed to fetch models from custom API. Please check your configuration and try again."
-    );
-  }
-}
-export {
-  applyModelSpecificTransformations,
-  callGPT5ResponsesAPI,
-  createStreamProcessor,
-  fetchCustomModels,
-  getCompletionWithProfile,
-  getGPT5CompletionWithProfile,
-  getModelFeatures,
-  normalizeRequestParams,
-  streamCompletion
-};
-//# sourceMappingURL=openai.js.map