ai-zero-token 2.0.5 → 2.0.7

package/dist/core/providers/http-client.js

@@ -7,6 +7,9 @@ import { PassThrough, Readable } from "node:stream";
 import { loadSettings } from "../store/settings-store.js";
 const CURL_STATUS_MARKER = "\n__CURL_STATUS__:";
 const CURL_HEADERS_MARKER = "\n__CURL_HEADERS__:";
+const DEFAULT_CURL_STREAM_HEADER_TIMEOUT_MS = 18e4;
+const MIN_CURL_STREAM_HEADER_TIMEOUT_MS = 3e4;
+const MAX_CURL_STREAM_HEADER_TIMEOUT_MS = 6e5;
 let requestSequence = 0;
 function nextRequestId() {
   requestSequence += 1;
@@ -29,6 +32,17 @@ function safeConsole(method, message, meta) {
   } catch {
   }
 }
+function getCurlStreamHeaderTimeoutMs(timeoutMs) {
+  if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+    return Math.max(1e3, timeoutMs);
+  }
+  const configured = process.env.AZT_CURL_STREAM_HEADER_TIMEOUT_MS?.trim();
+  const parsed = configured ? Number.parseInt(configured, 10) : NaN;
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return Math.min(MAX_CURL_STREAM_HEADER_TIMEOUT_MS, Math.max(MIN_CURL_STREAM_HEADER_TIMEOUT_MS, parsed));
+  }
+  return DEFAULT_CURL_STREAM_HEADER_TIMEOUT_MS;
+}
 function logHttpTiming(params) {
   safeConsole("info", "[http] request timing", {
     requestId: params.requestId,
@@ -42,6 +56,60 @@ function logHttpTiming(params) {
     totalMs: params.timing.totalMs
   });
 }
+function createHttpTransportError(message, params) {
+  const error = new Error(message);
+  error.code = params.code;
+  error.elapsedMs = roundMs(params.elapsedMs);
+  error.isTransient = params.transient ?? true;
+  error.method = params.method;
+  error.requestId = params.requestId;
+  error.statusCode = params.statusCode;
+  error.transport = params.transport;
+  error.upstreamConnectionError = params.upstreamConnectionError ?? true;
+  error.url = params.url;
+  return error;
+}
+function classifyCurlRequestError(stderr, exitCode) {
+  const normalized = stderr.toLowerCase();
+  if (exitCode === 35 || normalized.includes("ssl_connect") || normalized.includes("ssl_error_syscall")) {
+    return {
+      code: "curl_request_tls_failed",
+      statusCode: 502
+    };
+  }
+  if (exitCode === 6 || normalized.includes("could not resolve host") || normalized.includes("name lookup timed out")) {
+    return {
+      code: "curl_request_dns_failed",
+      statusCode: 502
+    };
+  }
+  if (exitCode === 7 || normalized.includes("failed to connect") || normalized.includes("connection refused")) {
+    return {
+      code: "curl_request_connect_failed",
+      statusCode: 502
+    };
+  }
+  if (exitCode === 28 || normalized.includes("operation timed out") || normalized.includes("timed out")) {
+    return {
+      code: "curl_request_timeout",
+      statusCode: 504
+    };
+  }
+  return {
+    code: "curl_request_failed",
+    statusCode: 502
+  };
+}
+function isTransientHttpError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const details = error;
+  if (details.isTransient === true || details.upstreamConnectionError === true) {
+    return true;
+  }
+  return typeof details.code === "string" && (details.code === "curl_stream_closed_before_headers" || details.code === "curl_stream_header_timeout" || details.code === "curl_stream_body_failed" || details.code === "curl_request_tls_failed" || details.code === "curl_request_dns_failed" || details.code === "curl_request_connect_failed" || details.code === "curl_request_timeout" || details.code === "curl_request_failed");
+}
 function isElectronRuntime() {
   return typeof process.versions.electron === "string";
 }
@@ -69,12 +137,7 @@ function normalizeCurlHeaders(value) {
     })
   );
 }
-function parseCurlHeaderDump(raw) {
-  const blocks = raw.replace(/\r\n/g, "\n").split(/\n\n+/).map((block2) => block2.trim()).filter((block2) => /^HTTP\//i.test(block2));
-  const block = blocks[blocks.length - 1];
-  if (!block) {
-    return null;
-  }
+function parseCurlHeaderBlock(block) {
   const lines = block.split("\n");
   const statusMatch = /^HTTP(?:\/\S+)?\s+(\d{3})/i.exec(lines[0]?.trim() ?? "");
   const status = statusMatch ? Number.parseInt(statusMatch[1], 10) : NaN;
@@ -96,6 +159,33 @@ function parseCurlHeaderDump(raw) {
   }
   return { status, headers };
 }
+function parseCurlHeaderDump(raw) {
+  const normalized = raw.replace(/\r\n/g, "\n");
+  const blocks = [];
+  let blockStart = 0;
+  while (blockStart < normalized.length) {
+    const separatorIndex = normalized.indexOf("\n\n", blockStart);
+    if (separatorIndex === -1) {
+      break;
+    }
+    const block = normalized.slice(blockStart, separatorIndex).trim();
+    if (/^HTTP\//i.test(block)) {
+      blocks.push(block);
+    }
+    blockStart = separatorIndex + 2;
+    while (normalized[blockStart] === "\n") {
+      blockStart += 1;
+    }
+  }
+  for (let index = blocks.length - 1; index >= 0; index -= 1) {
+    const parsed = parseCurlHeaderBlock(blocks[index]);
+    if (!parsed || parsed.status >= 100 && parsed.status < 200) {
+      continue;
+    }
+    return parsed;
+  }
+  return null;
+}
 async function runCurlRequest(init, params) {
   const requestId = params?.requestId ?? nextRequestId();
   const startedAt = performance.now();
@@ -152,7 +242,20 @@ async function runCurlRequest(init, params) {
   });
   phases.waitForCurlMs = performance.now() - startedAt - phases.spawnCurlMs;
   if (exitCode !== 0) {
-    throw new Error(stderr.trim() || `curl \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}`);
+    const stderrText = stderr.trim();
+    const classification = classifyCurlRequestError(stderrText, exitCode);
+    throw createHttpTransportError(
+      stderrText || `curl \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}\uFF08requestId=${requestId}\uFF09\u3002`,
+      {
+        code: classification.code,
+        elapsedMs: performance.now() - startedAt,
+        method: init.method,
+        requestId,
+        statusCode: classification.statusCode,
+        transport: "curl",
+        url: init.url
+      }
+    );
   }
   const parseStartedAt = performance.now();
   const statusMarkerIndex = stdout.lastIndexOf(CURL_STATUS_MARKER);
@@ -210,16 +313,45 @@ async function waitForCurlHeaders(params) {
       const raw = await fs.readFile(params.headerPath, "utf8");
       const parsed = parseCurlHeaderDump(raw);
       if (parsed) {
+        if (parsed.status >= 300 && parsed.status < 400 && !params.isClosed()) {
+          await new Promise((resolve) => setTimeout(resolve, 25));
+          continue;
+        }
         return parsed;
       }
     } catch {
     }
     if (params.isClosed()) {
-      throw new Error(params.stderr().trim() || "curl stream \u8BF7\u6C42\u5728\u8FD4\u56DE\u54CD\u5E94\u5934\u524D\u7ED3\u675F\u3002");
+      const stderr2 = params.stderr().trim();
+      const exitCode = params.exitCode();
+      throw createHttpTransportError(
+        stderr2 || `curl stream \u8BF7\u6C42\u5728\u8FD4\u56DE\u54CD\u5E94\u5934\u524D\u7ED3\u675F\uFF08requestId=${params.requestId}${exitCode ? `, exitCode=${exitCode}` : ""}\uFF09\u3002`,
+        {
+          code: "curl_stream_closed_before_headers",
+          elapsedMs: performance.now() - startedAt,
+          method: params.method,
+          requestId: params.requestId,
+          statusCode: 502,
+          transport: "curl",
+          url: params.url
+        }
+      );
     }
     await new Promise((resolve) => setTimeout(resolve, 25));
   }
-  throw new Error("\u7B49\u5F85 curl stream \u54CD\u5E94\u5934\u8D85\u65F6\u3002");
+  const stderr = params.stderr().trim();
+  throw createHttpTransportError(
+    `\u7B49\u5F85 curl stream \u54CD\u5E94\u5934\u8D85\u65F6\uFF08${Math.round(params.timeoutMs / 1e3)} \u79D2\uFF0CrequestId=${params.requestId}\uFF09\u3002${stderr ? ` ${stderr}` : ""}`,
+    {
+      code: "curl_stream_header_timeout",
+      elapsedMs: performance.now() - startedAt,
+      method: params.method,
+      requestId: params.requestId,
+      statusCode: 504,
+      transport: "curl",
+      url: params.url
+    }
+  );
 }
 async function runCurlStream(init, params) {
   if (init.signal?.aborted) {
@@ -266,6 +398,7 @@ async function runCurlStream(init, params) {
   child.stdin.on("error", () => void 0);
   child.stdin.end(hasBody ? init.body : void 0);
   const body = new PassThrough();
+  body.on("error", () => void 0);
   const phases = {
     spawnCurlMs: performance.now() - startedAt
   };
@@ -292,16 +425,31 @@ async function runCurlStream(init, params) {
     init.signal?.removeEventListener("abort", abort);
     void fs.unlink(headerPath).catch(() => void 0);
     if (exitCode !== 0 && !init.signal?.aborted) {
-      body.destroy(new Error(stderr.trim() || `curl stream \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}`));
+      body.destroy(createHttpTransportError(
+        stderr.trim() || `curl stream \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}\uFF08requestId=${requestId}\uFF09\u3002`,
+        {
+          code: "curl_stream_body_failed",
+          elapsedMs: performance.now() - startedAt,
+          method: init.method,
+          requestId,
+          statusCode: 502,
+          transport: "curl",
+          url: init.url
+        }
+      ));
     }
   });
   let parsed;
   try {
     parsed = await waitForCurlHeaders({
       headerPath,
+      method: init.method,
       isClosed: () => closed,
+      exitCode: () => exitCode,
       stderr: () => stderr,
-      timeoutMs: typeof params?.timeoutMs === "number" ? Math.min(params.timeoutMs, 3e4) : 3e4
+      requestId,
+      timeoutMs: getCurlStreamHeaderTimeoutMs(params?.timeoutMs),
+      url: init.url
     });
   } catch (error) {
     child.kill("SIGTERM");
@@ -461,6 +609,7 @@ async function requestStream(init) {
   });
 }
 export {
+  isTransientHttpError,
   requestStream,
   requestText
 };

package/dist/core/providers/openai-codex/chat.js

@@ -2,6 +2,7 @@
 import { DEFAULT_CODEX_MODEL } from "../../models/openai-codex-models.js";
 import { requestStream, requestText } from "../http-client.js";
 const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+const CODEX_RESPONSES_COMPACT_URL = `${CODEX_RESPONSES_URL}/compact`;
 const URL_KEY_RE = /(url|uri|href|download|preview|thumbnail|image|asset|file)/i;
 const REFERENCE_KEY_RE = /(image|asset|file|media|blob|artifact|download|preview|thumbnail)/i;
 const REFERENCE_VALUE_RE = /^(file|asset|image|img|media|blob)-[\w-]+$/i;
@@ -428,7 +429,7 @@ async function streamOpenAICodex(params) {
   }
   const response = await requestStream({
     method: "POST",
-    url: CODEX_RESPONSES_URL,
+    url: params.endpoint === "responses/compact" ? CODEX_RESPONSES_COMPACT_URL : CODEX_RESPONSES_URL,
     headers: buildCodexRequestHeaders(params.profile),
     body: JSON.stringify(requestBody),
     signal: params.signal