@within-7/minto 0.0.5-dev.1

package/dist/services/openai.js

@@ -0,0 +1,995 @@
+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";
+const RETRY_CONFIG = {
+  BASE_DELAY_MS: 1e3,
+  MAX_DELAY_MS: 32e3,
+  MAX_SERVER_DELAY_MS: 6e4,
+  JITTER_FACTOR: 0.1
+};
+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);
+    }
+  }
+  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 });
+    }
+  });
+}
+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}`;
+}
+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) => {
+      console.log(`\u{1F527} 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: "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) => {
+      console.log(`\u{1F527} GPT-5 Fix: Adjusting 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: "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;
+          }
+        }
+      }
+    }
+  }
+];
+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 },
+  "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)) {
+      console.log(`\u{1F527} Transforming max_tokens (${opts.max_tokens}) to max_completion_tokens for ${opts.model}`);
+      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}`
+        );
+        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;
+    }
+  }
+}
+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;
+    }
+  }
+}
+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;
+  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
+        // 🔧 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...`
+        );
+        continue;
+      }
+      return { response, endpoint };
+    } catch (error) {
+      lastError = error;
+      if (endpointsToTry.indexOf(endpoint) < endpointsToTry.length - 1) {
+        console.log(`Network error on ${endpoint}, trying next endpoint...`);
+        continue;
+      }
+    }
+  }
+  throw lastError || new Error("All endpoints failed");
+}
+async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAttempts = 10, signal) {
+  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) : void 0;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    if (provider === "azure") {
+      headers["api-key"] = apiKey;
+    } else {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+  }
+  applyModelSpecificTransformations(opts);
+  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, 8) : 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 === "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) {
+      const isOpenAICompatible2 = [
+        "minimax",
+        "kimi",
+        "deepseek",
+        "siliconflow",
+        "qwen",
+        "glm",
+        "baidu-qianfan",
+        "openai",
+        "mistral",
+        "xai",
+        "groq",
+        "custom-openai"
+      ].includes(provider);
+      let response2;
+      let usedEndpoint2;
+      if (isOpenAICompatible2 && provider !== "azure") {
+        const result = await tryWithEndpointFallback(
+          baseURL,
+          opts,
+          headers,
+          provider,
+          proxy,
+          signal
+          // 🔧 Pass AbortSignal to endpoint fallback
+        );
+        response2 = result.response;
+        usedEndpoint2 = result.endpoint;
+      } else {
+        response2 = await fetch(`${baseURL}${endpoint}`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ ...opts, stream: true }),
+          dispatcher: proxy,
+          signal
+          // 🔧 CRITICAL FIX: Connect AbortSignal to fetch call
+        });
+        usedEndpoint2 = endpoint;
+      }
+      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)) {
+              console.log(`\u{1F527} Detected ${handler.type} error for ${opts.model}: ${errorMessage}`);
+              setModelError(baseURL || "", opts.model, handler.type, errorMessage);
+              await handler.fix(opts);
+              console.log(`\u{1F527} Applied fix for ${handler.type}, retrying...`);
+              return getCompletionWithProfile(
+                modelProfile,
+                opts,
+                attempt + 1,
+                maxAttempts,
+                signal
+              );
+            }
+          }
+          console.log(`\u26A0\uFE0F  Unhandled API error (${response2.status}): ${errorMessage}`);
+          logAPIError({
+            model: opts.model,
+            endpoint: `${baseURL}${endpoint}`,
+            status: response2.status,
+            error: errorMessage,
+            request: opts,
+            response: errorData,
+            provider
+          });
+        } catch (parseError) {
+          console.log(`\u26A0\uFE0F  Could not parse error response (${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);
+        console.log(
+          `  \u23BF  API error (${response2.status}), retrying in ${Math.round(delayMs / 1e3)}s... (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;
+    }
+    const isOpenAICompatible = [
+      "minimax",
+      "kimi",
+      "deepseek",
+      "siliconflow",
+      "qwen",
+      "glm",
+      "baidu-qianfan",
+      "openai",
+      "mistral",
+      "xai",
+      "groq",
+      "custom-openai"
+    ].includes(provider);
+    let response;
+    let usedEndpoint;
+    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
+        // 🔧 CRITICAL FIX: Connect AbortSignal to non-streaming fetch call
+      });
+      usedEndpoint = endpoint;
+    }
+    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)) {
+            console.log(`\u{1F527} Detected ${handler.type} error for ${opts.model}: ${errorMessage}`);
+            setModelError(baseURL || "", opts.model, handler.type, errorMessage);
+            await handler.fix(opts);
+            console.log(`\u{1F527} Applied fix for ${handler.type}, retrying...`);
+            return getCompletionWithProfile(
+              modelProfile,
+              opts,
+              attempt + 1,
+              maxAttempts,
+              signal
+            );
+          }
+        }
+        console.log(`\u26A0\uFE0F  Unhandled API error (${response.status}): ${errorMessage}`);
+      } catch (parseError) {
+        console.log(`\u26A0\uFE0F  Could not parse error response (${response.status})`);
+      }
+      const delayMs = getRetryDelay(attempt);
+      console.log(
+        `  \u23BF  API error (${response.status}), retrying in ${Math.round(delayMs / 1e3)}s... (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);
+      console.log(
+        `  \u23BF  Network error, retrying in ${Math.round(delayMs / 1e3)}s... (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 error;
+  }
+}
+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 reader.read();
+        } catch (e) {
+          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);
+              yield parsed;
+            } catch (e) {
+              console.error("Error parsing JSON:", data, 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) {
+              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);
+      }
+    }
+  })();
+}
+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 = modelProfile?.apiKey;
+  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_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`;
+    }
+  }
+  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 = 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", {
+      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})`);
+    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`);
+    }
+  } 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(`\u{1F504} Using Chat Completions for streaming (Responses API streaming not available)`);
+  }
+  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"
+      }
+    });
+    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;
+    }
+    console.error("Failed to fetch custom API models:", 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,
+  streamCompletion
+};
+//# sourceMappingURL=openai.js.map