@shareai-lab/kode 2.0.2 → 2.0.3

package/dist/{chunk-ZQU3TXLC.js → chunks/chunk-IFCIADS3.js}

@@ -1,55 +1,152 @@
-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";
+} from "./chunk-ZCLTZIVP.js";
 import {
   debug,
   getCurrentRequest,
   logAPIError
-} from "./chunk-QYFKRZQC.js";
+} from "./chunk-YIO5EBMQ.js";
+import {
+  getGlobalConfig
+} from "./chunk-XR2W3MAM.js";
 
-// src/services/ai/openai.ts
-import { ProxyAgent, fetch } from "undici";
-var RETRY_CONFIG = {
-  BASE_DELAY_MS: 1e3,
-  MAX_DELAY_MS: 32e3,
-  MAX_SERVER_DELAY_MS: 6e4,
-  JITTER_FACTOR: 0.1
+// packages/core/src/ai/openai/completion.ts
+import { ProxyAgent as ProxyAgentCtor, fetch as fetch2 } from "undici";
+
+// packages/core/src/constants/models/providers.ts
+var providers = {
+  kimi: {
+    name: "Kimi (Moonshot)",
+    baseURL: "https://api.moonshot.cn/v1"
+  },
+  anthropic: {
+    name: "Messages API (Native)",
+    baseURL: "https://api.anthropic.com"
+  },
+  burncloud: {
+    name: "BurnCloud (All models)",
+    baseURL: "https://ai.burncloud.com/v1"
+  },
+  deepseek: {
+    name: "DeepSeek",
+    baseURL: "https://api.deepseek.com"
+  },
+  qwen: {
+    name: "Qwen (Alibaba)",
+    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
+  },
+  openai: {
+    name: "OpenAI",
+    baseURL: "https://api.openai.com/v1"
+  },
+  ollama: {
+    name: "Ollama",
+    baseURL: "http://localhost:11434/v1"
+  },
+  gemini: {
+    name: "Gemini",
+    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai"
+  },
+  "custom-openai": {
+    name: "Custom OpenAI-Compatible API",
+    baseURL: ""
+    // Will be configured by user
+  },
+  openrouter: {
+    name: "OpenRouter",
+    baseURL: "https://openrouter.ai/api/v1"
+  },
+  minimax: {
+    name: "MiniMax",
+    baseURL: "https://api.minimaxi.com/v1"
+  },
+  "minimax-coding": {
+    name: "MiniMax Coding Plan",
+    baseURL: "https://api.minimaxi.com/anthropic"
+  },
+  siliconflow: {
+    name: "SiliconFlow",
+    baseURL: "https://api.siliconflow.cn/v1"
+  },
+  glm: {
+    name: "GLM (Zhipu AI)",
+    baseURL: "https://open.bigmodel.cn/api/paas/v4"
+  },
+  "glm-coding": {
+    name: "GLM Coding Plan",
+    baseURL: "https://open.bigmodel.cn/api/coding/paas/v4"
+  },
+  "baidu-qianfan": {
+    name: "Baidu Qianfan",
+    baseURL: "https://qianfan.baidubce.com/v2"
+  },
+  mistral: {
+    name: "Mistral",
+    baseURL: "https://api.mistral.ai/v1"
+  },
+  xai: {
+    name: "xAI",
+    baseURL: "https://api.x.ai/v1"
+  },
+  groq: {
+    name: "Groq",
+    baseURL: "https://api.groq.com/openai/v1"
+  },
+  azure: {
+    name: "Azure OpenAI",
+    baseURL: ""
+    // Will be dynamically constructed based on resource name
+  }
 };
-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);
-    }
+
+// packages/core/src/ai/openai/endpointFallback.ts
+import { fetch } from "undici";
+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");
   }
-  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 });
+  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
+      });
+      if (response.ok) {
+        return { response, endpoint };
+      }
+      if (response.status === 404 && endpointsToTry.length > 1) {
+        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) {
+        debug.api("OPENAI_ENDPOINT_FALLBACK", {
+          endpoint,
+          reason: "network_error",
+          error: error instanceof Error ? error.message : String(error)
+        });
+        continue;
+      }
     }
-  });
+  }
+  throw lastError instanceof Error ? lastError : new Error("All endpoints failed");
 }
+
+// packages/core/src/ai/openai/modelErrors.ts
 function getModelErrorKey(baseURL, model, type) {
   return `${baseURL}:${model}:${type}`;
 }
@@ -104,24 +201,20 @@ var ERROR_HANDLERS = [
         if (tool.function.description.length <= 1024) continue;
         let str = "";
         let remainder = "";
-        for (let line of tool.function.description.split("\n")) {
+        for (const line of tool.function.description.split("\\n")) {
           if (str.length + line.length < 1024) {
-            str += line + "\n";
+            str += line + "\\n";
           } else {
-            remainder += line + "\n";
+            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";
+        let content = "<additional-tool-usage-instructions>\\n\\n";
         for (const [name, description] of Object.entries(toolDescriptions)) {
-          content += `<${name}>
-${description}
-</${name}>
-
-`;
+          content += `<${name}>\\n${description}\\n</${name}>\\n\\n`;
         }
         content += "</additional-tool-usage-instructions>";
         for (let i = opts.messages.length - 1; i >= 0; i--) {
@@ -177,6 +270,43 @@ ${description}
     }
   }
 ];
+function handlersForModel(model) {
+  return model.startsWith("gpt-5") ? [...GPT5_ERROR_HANDLERS, ...ERROR_HANDLERS] : ERROR_HANDLERS;
+}
+async function applyModelErrorFixes(opts, baseURL) {
+  for (const handler of handlersForModel(opts.model)) {
+    if (hasModelError(baseURL, opts.model, handler.type)) {
+      await handler.fix(opts);
+      return;
+    }
+  }
+}
+async function maybeFixModelError(args) {
+  for (const handler of handlersForModel(args.opts.model)) {
+    if (!handler.detect(args.errorMessage)) continue;
+    debug.api("OPENAI_MODEL_ERROR_DETECTED", {
+      model: args.opts.model,
+      type: handler.type,
+      errorMessage: args.errorMessage,
+      status: args.status
+    });
+    setModelError(
+      args.baseURL,
+      args.opts.model,
+      handler.type,
+      args.errorMessage
+    );
+    await handler.fix(args.opts);
+    debug.api("OPENAI_MODEL_ERROR_FIXED", {
+      model: args.opts.model,
+      type: handler.type
+    });
+    return true;
+  }
+  return false;
+}
+
+// packages/core/src/ai/openai/modelFeatures.ts
 var MODEL_FEATURES = {
   o1: { usesMaxCompletionTokens: true },
   "o1-preview": { usesMaxCompletionTokens: true },
@@ -279,447 +409,84 @@ function applyModelSpecificTransformations(opts) {
     }
   }
 }
-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
-      });
-      if (response.ok) {
-        return { response, endpoint };
-      }
-      if (response.status === 404 && endpointsToTry.length > 1) {
-        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) {
-        debug.api("OPENAI_ENDPOINT_FALLBACK", {
-          endpoint,
-          reason: "network_error",
-          error: error instanceof Error ? error.message : String(error)
-        });
-        continue;
-      }
+
+// packages/core/src/ai/openai/retry.ts
+var 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);
     }
   }
-  throw lastError || new Error("All endpoints failed");
+  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);
 }
-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 || "");
-  debug.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",
-        "glm-coding",
-        "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
-        );
-        response2 = result.response;
-        usedEndpoint2 = result.endpoint;
-      } else {
-        response2 = await fetch(`${baseURL}${endpoint}`, {
-          method: "POST",
-          headers,
-          body: JSON.stringify({ ...opts, stream: true }),
-          dispatcher: proxy,
-          signal
-        });
-        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)) {
-              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);
-              debug.api("OPENAI_MODEL_ERROR_FIXED", {
-                model: opts.model,
-                type: handler.type
-              });
-              return getCompletionWithProfile(
-                modelProfile,
-                opts,
-                attempt + 1,
-                maxAttempts,
-                signal
-              );
-            }
-          }
-          debug.warn("OPENAI_API_ERROR_UNHANDLED", {
-            model: opts.model,
-            status: response2.status,
-            errorMessage
-          });
-          logAPIError({
-            model: opts.model,
-            endpoint: `${baseURL}${endpoint}`,
-            status: response2.status,
-            error: errorMessage,
-            request: opts,
-            response: errorData,
-            provider
-          });
-        } catch (parseError) {
-          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}`,
-            status: response2.status,
-            error: `Could not parse error response: ${parseError.message}`,
-            request: opts,
-            response: { parseError: parseError.message },
-            provider
-          });
-        }
-        const delayMs = getRetryDelay(attempt);
-        debug.warn("OPENAI_API_RETRY", {
-          model: opts.model,
-          status: response2.status,
-          attempt: attempt + 1,
-          maxAttempts,
-          delayMs
-        });
-        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
-        );
-      }
-      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
-      );
-      response = result.response;
-      usedEndpoint = result.endpoint;
-    } else {
-      response = await fetch(`${baseURL}${endpoint}`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(opts),
-        dispatcher: proxy,
-        signal
-      });
-      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)) {
-            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);
-            debug.api("OPENAI_MODEL_ERROR_FIXED", {
-              model: opts.model,
-              type: handler.type
-            });
-            return getCompletionWithProfile(
-              modelProfile,
-              opts,
-              attempt + 1,
-              maxAttempts,
-              signal
-            );
-          }
-        }
-        debug.warn("OPENAI_API_ERROR_UNHANDLED", {
-          model: opts.model,
-          status: response.status,
-          errorMessage
-        });
-      } catch (parseError) {
-        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);
-      debug.warn("OPENAI_API_RETRY", {
-        model: opts.model,
-        status: response.status,
-        attempt: attempt + 1,
-        maxAttempts,
-        delayMs
-      });
-      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
-      );
-    }
-    const responseData = await response.json();
-    return responseData;
-  } catch (error) {
+function abortableDelay(delayMs, signal) {
+  return new Promise((resolve, reject) => {
     if (signal?.aborted) {
-      throw new Error("Request cancelled by user");
+      reject(new Error("Request was aborted"));
+      return;
     }
-    if (attempt < maxAttempts) {
-      if (signal?.aborted) {
-        throw new Error("Request cancelled by user");
-      }
-      const delayMs = getRetryDelay(attempt);
-      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) {
-        if (error2.message === "Request was aborted") {
-          throw new Error("Request cancelled by user");
-        }
-        throw error2;
-      }
-      return getCompletionWithProfile(
-        modelProfile,
-        opts,
-        attempt + 1,
-        maxAttempts,
-        signal
-      );
+    const timeoutId = setTimeout(() => resolve(), delayMs);
+    if (signal) {
+      const abortHandler = () => {
+        clearTimeout(timeoutId);
+        reject(new Error("Request was aborted"));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
     }
-    throw error;
-  }
+  });
 }
+
+// packages/core/src/ai/openai/stream.ts
 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;
-        }
+        if (signal?.aborted) break;
         let readResult;
         try {
           readResult = await reader.read();
         } catch (e) {
-          if (signal?.aborted) {
-            break;
-          }
+          if (signal?.aborted) break;
           debug.warn("OPENAI_STREAM_READ_ERROR", {
             error: e instanceof Error ? e.message : String(e)
           });
           break;
         }
         const { done, value } = readResult;
-        if (done) {
-          break;
-        }
-        const chunk = decoder.decode(value, { stream: true });
-        buffer += chunk;
+        if (done) break;
+        const chunk = value instanceof Uint8Array ? value : new Uint8Array();
+        buffer += decoder.decode(chunk, { stream: true });
         let lineEnd = buffer.indexOf("\n");
         while (lineEnd !== -1) {
           const line = buffer.substring(0, lineEnd).trim();
           buffer = buffer.substring(lineEnd + 1);
           if (line === "data: [DONE]") {
+            lineEnd = buffer.indexOf("\n");
             continue;
           }
           if (line.startsWith("data: ")) {
             const data = line.slice(6).trim();
-            if (!data) continue;
-            try {
-              const parsed = JSON.parse(data);
-              yield parsed;
-            } catch (e) {
-              debug.warn("OPENAI_STREAM_JSON_PARSE_ERROR", {
-                data,
-                error: e instanceof Error ? e.message : String(e)
-              });
+            if (data) {
+              try {
+                yield JSON.parse(data);
+              } catch (e) {
+                debug.warn("OPENAI_STREAM_JSON_PARSE_ERROR", {
+                  data,
+                  error: e instanceof Error ? e.message : String(e)
+                });
+              }
             }
           }
           lineEnd = buffer.indexOf("\n");
@@ -728,18 +495,16 @@ function createStreamProcessor(stream, signal) {
       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) {
-              debug.warn("OPENAI_STREAM_FINAL_JSON_PARSE_ERROR", {
-                data,
-                error: e instanceof Error ? e.message : String(e)
-              });
-            }
+          if (!line.startsWith("data: ") || line === "data: [DONE]") continue;
+          const data = line.slice(6).trim();
+          if (!data) continue;
+          try {
+            yield JSON.parse(data);
+          } catch (e) {
+            debug.warn("OPENAI_STREAM_FINAL_JSON_PARSE_ERROR", {
+              data,
+              error: e instanceof Error ? e.message : String(e)
+            });
           }
         }
       }
@@ -761,65 +526,286 @@ function createStreamProcessor(stream, signal) {
 function streamCompletion(stream, signal) {
   return createStreamProcessor(stream, 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;
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${apiKey}`
-  };
-  const responsesParams = request;
-  try {
-    const response = await fetch(`${baseURL}/responses`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(responsesParams),
-      dispatcher: proxy,
-      signal
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(
-        `GPT-5 Responses API error: ${response.status} ${response.statusText} - ${errorText}`
-      );
+
+// packages/core/src/ai/openai/completion.ts
+var STREAM_OPENAI_COMPATIBLE = [
+  "minimax",
+  "kimi",
+  "deepseek",
+  "siliconflow",
+  "qwen",
+  "glm",
+  "glm-coding",
+  "baidu-qianfan",
+  "openai",
+  "mistral",
+  "xai",
+  "groq",
+  "custom-openai"
+];
+var NON_STREAM_OPENAI_COMPATIBLE = [
+  "minimax",
+  "kimi",
+  "deepseek",
+  "siliconflow",
+  "qwen",
+  "glm",
+  "baidu-qianfan",
+  "openai",
+  "mistral",
+  "xai",
+  "groq",
+  "custom-openai"
+];
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw new Error("Request cancelled by user");
+}
+function normalizeToolMessages(opts) {
+  opts.messages = opts.messages.map((msg) => {
+    if (msg.role !== "tool") return msg;
+    if (Array.isArray(msg.content)) {
+      return {
+        ...msg,
+        content: msg.content.map((c) => c.text || "").filter(Boolean).join("\\n\\n") || "(empty content)"
+      };
     }
-    return response;
-  } catch (error) {
-    if (signal?.aborted) {
-      throw new Error("Request cancelled by user");
+    if (typeof msg.content !== "string") {
+      return {
+        ...msg,
+        content: typeof msg.content === "undefined" ? "(empty content)" : JSON.stringify(msg.content)
+      };
     }
-    throw error;
+    return msg;
+  });
+}
+function parseErrorMessage(errorData, status) {
+  if (typeof errorData === "object" && errorData !== null) {
+    const record = errorData;
+    const errorObj = typeof record.error === "object" && record.error !== null ? record.error : null;
+    const nested = errorObj?.message;
+    if (typeof nested === "string" && nested.trim()) return nested;
+    const direct = record.message;
+    if (typeof direct === "string" && direct.trim()) return direct;
+  }
+  return `HTTP ${status}`;
+}
+function endpointForProvider(provider) {
+  const azureApiVersion = "2024-06-01";
+  if (provider === "azure") {
+    return `/chat/completions?api-version=${azureApiVersion}`;
   }
+  if (provider === "minimax") {
+    return "/text/chatcompletion_v2";
+  }
+  return "/chat/completions";
 }
+function createProxy() {
+  return getGlobalConfig().proxy ? new ProxyAgentCtor(getGlobalConfig().proxy) : void 0;
+}
+function createHeaders(provider, apiKey) {
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) {
+    if (provider === "azure") {
+      headers["api-key"] = apiKey;
+    } else {
+      headers.Authorization = `Bearer ${apiKey}`;
+    }
+  }
+  return headers;
+}
+async function fetchCompletionResponse(args) {
+  const isOpenAICompatible = args.stream ? STREAM_OPENAI_COMPATIBLE.includes(
+    args.provider
+  ) : NON_STREAM_OPENAI_COMPATIBLE.includes(
+    args.provider
+  );
+  if (isOpenAICompatible && args.provider !== "azure") {
+    return await tryWithEndpointFallback(
+      args.baseURL,
+      args.opts,
+      args.headers,
+      args.provider,
+      args.proxy,
+      args.signal
+    );
+  }
+  const response = await fetch2(`${args.baseURL}${args.endpoint}`, {
+    method: "POST",
+    headers: args.headers,
+    body: JSON.stringify(
+      args.stream ? { ...args.opts, stream: true } : args.opts
+    ),
+    dispatcher: args.proxy,
+    signal: args.signal
+  });
+  return { response, endpoint: args.endpoint };
+}
+async function getCompletionWithProfile(modelProfile, opts, attempt = 0, maxAttempts = 10, signal) {
+  const profile = modelProfile;
+  const provider = profile?.provider || "anthropic";
+  const providerConfig = providers[provider];
+  const baseURL = profile?.baseURL || providerConfig?.baseURL || "";
+  const apiKey = profile?.apiKey;
+  const proxy = createProxy();
+  const headers = createHeaders(provider, apiKey);
+  for (let currentAttempt = attempt; currentAttempt < maxAttempts; currentAttempt++) {
+    throwIfAborted(signal);
+    applyModelSpecificTransformations(opts);
+    await applyModelErrorFixes(opts, baseURL || "");
+    normalizeToolMessages(opts);
+    debug.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: profile?.modelName,
+      modelProfileName: profile?.name
+    });
+    const endpoint = endpointForProvider(provider);
+    try {
+      const wantsStream = !!opts.stream;
+      const { response, endpoint: usedEndpoint } = await fetchCompletionResponse({
+        baseURL,
+        endpoint,
+        provider,
+        proxy,
+        headers,
+        opts,
+        stream: wantsStream,
+        signal
+      });
+      if (!response.ok) {
+        throwIfAborted(signal);
+        try {
+          const errorData = await response.json();
+          const errorMessage = parseErrorMessage(errorData, response.status);
+          const fixed = await maybeFixModelError({
+            baseURL: baseURL || "",
+            opts,
+            errorMessage,
+            status: response.status
+          });
+          if (fixed) {
+            continue;
+          }
+          debug.warn("OPENAI_API_ERROR_UNHANDLED", {
+            model: opts.model,
+            status: response.status,
+            errorMessage
+          });
+          if (wantsStream) {
+            logAPIError({
+              model: opts.model,
+              endpoint: `${baseURL}${usedEndpoint}`,
+              status: response.status,
+              error: errorMessage,
+              request: opts,
+              response: errorData,
+              provider
+            });
+          }
+        } catch (parseError) {
+          debug.warn("OPENAI_API_ERROR_PARSE_FAILED", {
+            model: opts.model,
+            status: response.status,
+            error: parseError instanceof Error ? parseError.message : String(parseError)
+          });
+          if (wantsStream) {
+            logAPIError({
+              model: opts.model,
+              endpoint: `${baseURL}${usedEndpoint}`,
+              status: response.status,
+              error: `Could not parse error response: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+              request: opts,
+              response: {
+                parseError: parseError instanceof Error ? parseError.message : String(parseError)
+              },
+              provider
+            });
+          }
+        }
+        debug.warn("OPENAI_API_RETRY", {
+          model: opts.model,
+          status: response.status,
+          attempt: currentAttempt + 1,
+          maxAttempts,
+          delayMs: getRetryDelay(currentAttempt)
+        });
+        await abortableDelay(getRetryDelay(currentAttempt), signal).catch(
+          (err) => {
+            if (err instanceof Error && err.message === "Request was aborted") {
+              throw new Error("Request cancelled by user");
+            }
+            throw err;
+          }
+        );
+        continue;
+      }
+      if (wantsStream) {
+        const body = response.body;
+        if (!body) throw new Error("Stream is null or undefined");
+        return createStreamProcessor(body, signal);
+      }
+      return await response.json();
+    } catch (error) {
+      throwIfAborted(signal);
+      if (currentAttempt + 1 >= maxAttempts) {
+        throw error;
+      }
+      debug.warn("OPENAI_NETWORK_RETRY", {
+        model: opts.model,
+        attempt: currentAttempt + 1,
+        maxAttempts,
+        delayMs: getRetryDelay(currentAttempt),
+        error: error instanceof Error ? error.message : String(error)
+      });
+      await abortableDelay(getRetryDelay(currentAttempt), signal).catch((err) => {
+        if (err instanceof Error && err.message === "Request was aborted") {
+          throw new Error("Request cancelled by user");
+        }
+        throw err;
+      });
+    }
+  }
+  throw new Error("Max attempts reached");
+}
+
+// packages/core/src/ai/openai/gpt5.ts
 async function getGPT5CompletionWithProfile(modelProfile, opts, attempt = 0, maxAttempts = 10, signal) {
+  const profile = modelProfile;
   const features = getModelFeatures(opts.model);
-  const isOfficialOpenAI = !modelProfile.baseURL || modelProfile.baseURL.includes("api.openai.com");
+  const isOfficialOpenAI = !profile?.baseURL || profile.baseURL.includes("api.openai.com");
   if (!isOfficialOpenAI) {
     debug.api("GPT5_THIRD_PARTY_PROVIDER", {
       model: opts.model,
-      baseURL: modelProfile.baseURL,
-      provider: modelProfile.provider,
+      baseURL: profile?.baseURL,
+      provider: profile?.provider,
       supportsResponsesAPI: features.supportsResponsesAPI,
       requestId: getCurrentRequest()?.id
     });
     debug.api("GPT5_PROVIDER_THIRD_PARTY_NOTICE", {
       model: opts.model,
-      provider: modelProfile.provider,
-      baseURL: modelProfile.baseURL
+      provider: profile?.provider,
+      baseURL: profile?.baseURL
     });
-    if (modelProfile.provider === "azure") {
+    if (profile?.provider === "azure") {
       delete opts.reasoning_effort;
-    } else if (modelProfile.provider === "custom-openai") {
+    } else if (profile?.provider === "custom-openai") {
       debug.api("GPT5_CUSTOM_PROVIDER_OPTIMIZATIONS", {
         model: opts.model,
-        provider: modelProfile.provider
+        provider: profile?.provider
       });
     }
   } else if (opts.stream) {
     debug.api("GPT5_STREAMING_MODE", {
       model: opts.model,
-      baseURL: modelProfile.baseURL || "official",
+      baseURL: profile?.baseURL || "official",
       reason: "responses_api_no_streaming",
       requestId: getCurrentRequest()?.id
     });
@@ -830,8 +816,8 @@ async function getGPT5CompletionWithProfile(modelProfile, opts, attempt = 0, max
   }
   debug.api("USING_CHAT_COMPLETIONS_FOR_GPT5", {
     model: opts.model,
-    baseURL: modelProfile.baseURL || "official",
-    provider: modelProfile.provider,
+    baseURL: profile?.baseURL || "official",
+    provider: profile?.provider,
     reason: isOfficialOpenAI ? "streaming_or_fallback" : "third_party_provider",
     requestId: getCurrentRequest()?.id
   });
@@ -843,94 +829,106 @@ async function getGPT5CompletionWithProfile(modelProfile, opts, attempt = 0, max
     signal
   );
 }
-async function fetchCustomModels(baseURL, apiKey) {
+
+// packages/core/src/ai/openai/responsesApi.ts
+import { ProxyAgent as ProxyAgentCtor2, fetch as fetch3 } from "undici";
+async function callGPT5ResponsesAPI(modelProfile, request, signal) {
+  const profile = modelProfile;
+  const baseURL = profile?.baseURL || "https://api.openai.com/v1";
+  const apiKey = profile?.apiKey;
+  const proxy = getGlobalConfig().proxy ? new ProxyAgentCtor2(getGlobalConfig().proxy) : void 0;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${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"
-      }
+    const response = await fetch3(`${baseURL}/responses`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      dispatcher: proxy,
+      signal
     });
     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 errorText = await response.text();
+      throw new Error(
+        `GPT-5 Responses API error: ${response.status} ${response.statusText} - ${errorText}`
+      );
     }
-    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 {
+    return response;
+  } catch (error) {
+    if (signal?.aborted) {
+      throw new Error("Request cancelled by user");
+    }
+    throw error;
+  }
+}
+
+// packages/core/src/ai/openai/customModels.ts
+import { fetch as fetch4 } from "undici";
+function asRecord(value) {
+  if (typeof value !== "object" || value === null) return null;
+  return value;
+}
+function extractModelArray(value) {
+  const record = asRecord(value);
+  if (!record) return null;
+  if (Array.isArray(record.data)) return record.data;
+  if (Array.isArray(record.models)) return record.models;
+  return null;
+}
+async function fetchCustomModels(baseURL, apiKey) {
+  const hasVersionNumber = /\/v\d+/.test(baseURL);
+  const cleanBaseURL = baseURL.replace(/\/+$/, "");
+  const modelsURL = hasVersionNumber ? `${cleanBaseURL}/models` : `${cleanBaseURL}/v1/models`;
+  const response = await fetch4(modelsURL, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
       throw new Error(
-        'API returned unexpected response format. Expected an array of models or an object with a "data" or "models" array.'
+        "Invalid API key. Please check your API key and try again."
       );
     }
-    if (!Array.isArray(models)) {
-      throw new Error("API response format error: models data is not an array.");
+    if (response.status === 403) {
+      throw new Error(
+        "API key does not have permission to access models. Please check your API key permissions."
+      );
     }
-    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;
+    if (response.status === 404) {
+      throw new Error(
+        "API endpoint not found. Please check if the base URL is correct and supports the /models endpoint."
+      );
     }
-    debug.warn("CUSTOM_API_MODELS_FETCH_FAILED", {
-      baseURL,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    if (error instanceof Error && error.message.includes("fetch")) {
+    if (response.status === 429) {
       throw new Error(
-        "Unable to connect to the API. Please check the base URL and your internet connection."
+        "Rate limit exceeded. Please wait a moment and try again."
       );
     }
     throw new Error(
-      "Failed to fetch models from custom API. Please check your configuration and try again."
+      `Failed to fetch models: HTTP ${response.status} ${response.statusText}`
     );
   }
+  const json = await response.json();
+  const models = extractModelArray(json);
+  if (!models) {
+    throw new Error("Invalid response format: missing models array");
+  }
+  return models;
 }
 
 export {
+  providers,
   getModelFeatures,
   applyModelSpecificTransformations,
-  getCompletionWithProfile,
   createStreamProcessor,
   streamCompletion,
-  callGPT5ResponsesAPI,
+  getCompletionWithProfile,
   getGPT5CompletionWithProfile,
+  callGPT5ResponsesAPI,
   fetchCustomModels
 };