@qwen-code/qwen-code 0.23.3 → 0.23.4-nightly.20260914.f024b37689

package/chunks/chunk-TDS25ULF.js

@@ -0,0 +1,154 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getNestedProperty,
+  getPersistScopeForModelSelection
+} from "./chunk-ULPXHGLV.js";
+import {
+  getHomeEnvFallbackVars
+} from "./chunk-3CEFQSKN.js";
+import {
+  writeWithBackupSync
+} from "./chunk-F7WDCD2N.js";
+import {
+  resolveEnvVarsInObject
+} from "./chunk-65I7S4Z3.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/loadedSettingsAdapter.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+function preservePlaceholders(value, resolved, original) {
+  if (typeof original === "string" && value === resolved) return original;
+  if (Array.isArray(value) && Array.isArray(resolved) && Array.isArray(original)) {
+    return value.map(
+      (entry, index) => preservePlaceholders(entry, resolved[index], original[index])
+    );
+  }
+  if (value && resolved && original && typeof value === "object" && !Array.isArray(value) && typeof resolved === "object" && !Array.isArray(resolved) && typeof original === "object" && !Array.isArray(original)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        preservePlaceholders(
+          entry,
+          resolved[key],
+          original[key]
+        )
+      ])
+    );
+  }
+  return value;
+}
+__name(preservePlaceholders, "preservePlaceholders");
+function createLoadedSettingsAdapter(settings, scope) {
+  const persistScope = scope ?? getPersistScopeForModelSelection(settings);
+  const settingsFile = settings.forScope(persistScope);
+  let fileSnapshot;
+  let settingsSnapshot = null;
+  let originalSnapshot = null;
+  return {
+    getValue(key) {
+      return getNestedProperty(settings.merged, key);
+    },
+    setValue(key, value) {
+      for (const part of key.split(".")) {
+        if (part === "__proto__" || part === "constructor" || part === "prototype") {
+          throw new Error(
+            `Refusing to write settings key with reserved segment: ${key}`
+          );
+        }
+      }
+      const provider = key.startsWith("modelProviders.") && key.split(".").length === 2 ? key.slice("modelProviders.".length) : void 0;
+      if (!provider || !Array.isArray(value)) {
+        settings.setValue(persistScope, key, value);
+        return;
+      }
+      const previous = settings.merged.modelProviders?.[provider];
+      const source = [
+        "System" /* System */,
+        ...settings.isTrusted ? ["Workspace" /* Workspace */] : [],
+        "User" /* User */,
+        "SystemDefaults" /* SystemDefaults */
+      ].map(
+        (source2) => settings.forScope(source2).originalSettings.modelProviders
+      ).find((providers) => providers && Object.hasOwn(providers, provider));
+      const raw = source?.[provider];
+      const models = value;
+      const persisted = !Array.isArray(previous) || !Array.isArray(raw) ? models : models.map((model) => {
+        if (!model) return model;
+        const matches = previous.flatMap(
+          (entry, index2) => entry?.id === model.id && entry.baseUrl === model.baseUrl ? [index2] : []
+        );
+        if (matches.length > 1 && JSON.stringify(previous) !== JSON.stringify(raw)) {
+          throw new Error(
+            "Cannot preserve placeholders in an ambiguous model configuration. Remove duplicate model entries first."
+          );
+        }
+        const index = matches[0];
+        return index === void 0 ? model : preservePlaceholders(model, previous[index], raw[index]);
+      });
+      settings.setValue(persistScope, key, persisted);
+      settingsFile.settings.modelProviders = {
+        ...settingsFile.settings.modelProviders,
+        [provider]: resolveEnvVarsInObject(persisted, getHomeEnvFallbackVars())
+      };
+      settings.recomputeMerged();
+    },
+    getModelProviders() {
+      return settings.merged.modelProviders ?? {};
+    },
+    persist() {
+    },
+    backup() {
+      const contents = fs.existsSync(settingsFile.path) ? fs.readFileSync(settingsFile.path, "utf8") : null;
+      settingsSnapshot = structuredClone(settingsFile.settings);
+      originalSnapshot = structuredClone(settingsFile.originalSettings);
+      fileSnapshot = contents;
+    },
+    restore() {
+      if (fileSnapshot === void 0) return;
+      try {
+        if (fileSnapshot === null) {
+          fs.rmSync(settingsFile.path, { force: true });
+        } else {
+          writeWithBackupSync(settingsFile.path, fileSnapshot);
+        }
+      } finally {
+        if (settingsSnapshot !== null) {
+          settingsFile.settings = settingsSnapshot;
+        }
+        if (originalSnapshot !== null) {
+          settingsFile.originalSettings = originalSnapshot;
+        }
+        settings.recomputeMerged();
+      }
+    },
+    cleanupBackup() {
+      fileSnapshot = void 0;
+      settingsSnapshot = null;
+      originalSnapshot = null;
+    }
+  };
+}
+__name(createLoadedSettingsAdapter, "createLoadedSettingsAdapter");
+
+export {
+  createLoadedSettingsAdapter
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Adapter that lets core's `applyProviderInstallPlan` write through
+ * `LoadedSettings` while preserving CLI-specific guarantees:
+ * - scope resolution via `getPersistScopeForModelSelection`
+ * - original file contents for transaction rollback
+ * - in-memory snapshot of `settings` / `originalSettings` for rollback
+ * - merged-settings recomputation after restore
+ */

package/chunks/chunk-U6H3XTFA.js

@@ -0,0 +1,95 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/code-mode/protocol.ts
+init_esbuild_shims();
+var CODE_MODE_MAX_CONTROL_FRAME_BYTES = 1048576;
+var CODE_MODE_MAX_FRAME_BYTES = 16 * 1024 * 1024;
+var CODE_MODE_MAX_MEDIA_BYTES = 10 * 1024 * 1024;
+var CODE_MODE_MAX_MEDIA_ITEMS = 16;
+var CODE_MODE_MAX_SOURCE_CHARS = 131072;
+var CODE_MODE_MAX_OUTPUT_CHARS = 1e5;
+var CODE_MODE_TIMEOUT_MS = 3e4;
+function hasBoundedImageContent(message) {
+  if (message.type !== "tool_result") return false;
+  const content = message.result?.content;
+  if (!Array.isArray(content) || content.length === 0 || content.length > CODE_MODE_MAX_MEDIA_ITEMS) {
+    return false;
+  }
+  let decodedBytes = 0;
+  for (const item of content) {
+    if (item?.type !== "image" || typeof item.mimeType !== "string" || !item.mimeType.toLowerCase().startsWith("image/") || typeof item.data !== "string" || item.data.length === 0) {
+      return false;
+    }
+    const padding = item.data.endsWith("==") ? 2 : item.data.endsWith("=") ? 1 : 0;
+    decodedBytes += Math.floor(item.data.length * 3 / 4) - padding;
+    if (decodedBytes > CODE_MODE_MAX_MEDIA_BYTES) return false;
+  }
+  return true;
+}
+__name(hasBoundedImageContent, "hasBoundedImageContent");
+function maxFrameBytes(message) {
+  if (message.type === "complete" || message.type === "error") {
+    return CODE_MODE_MAX_FRAME_BYTES;
+  }
+  if (hasBoundedImageContent(message)) return CODE_MODE_MAX_FRAME_BYTES;
+  return CODE_MODE_MAX_CONTROL_FRAME_BYTES;
+}
+__name(maxFrameBytes, "maxFrameBytes");
+function encodeFrame(message) {
+  const body = Buffer.from(JSON.stringify(message));
+  if (body.byteLength > maxFrameBytes(message)) {
+    throw new Error("Code mode protocol frame exceeds the size limit.");
+  }
+  const frame = Buffer.allocUnsafe(body.byteLength + 4);
+  frame.writeUInt32BE(body.byteLength, 0);
+  body.copy(frame, 4);
+  return frame;
+}
+__name(encodeFrame, "encodeFrame");
+var FrameDecoder = class {
+  static {
+    __name(this, "FrameDecoder");
+  }
+  buffer = Buffer.alloc(0);
+  push(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    const messages = [];
+    while (this.buffer.byteLength >= 4) {
+      const length = this.buffer.readUInt32BE(0);
+      if (length > CODE_MODE_MAX_FRAME_BYTES) {
+        throw new Error("Code mode protocol frame exceeds the size limit.");
+      }
+      if (this.buffer.byteLength < length + 4) break;
+      const body = this.buffer.subarray(4, length + 4);
+      this.buffer = this.buffer.subarray(length + 4);
+      const message = JSON.parse(body.toString("utf8"));
+      if (length > maxFrameBytes(message)) {
+        throw new Error("Code mode protocol frame exceeds the size limit.");
+      }
+      messages.push(message);
+    }
+    return messages;
+  }
+};
+
+export {
+  CODE_MODE_MAX_MEDIA_BYTES,
+  CODE_MODE_MAX_MEDIA_ITEMS,
+  CODE_MODE_MAX_SOURCE_CHARS,
+  CODE_MODE_MAX_OUTPUT_CHARS,
+  CODE_MODE_TIMEOUT_MS,
+  encodeFrame,
+  FrameDecoder
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-Z3GF56ME.js → chunk-UDEWJKNB.js}

@@ -2,18 +2,18 @@
 "use strict";
 import {
   SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX
-} from "./chunk-3KQBQ6FM.js";
+} from "./chunk-FEMYSX4G.js";
 import {
   ChannelDeliveryError,
   MAX_CHANNEL_DELIVERY_TEXT_LENGTH
 } from "./chunk-RKFGE7JH.js";
 import {
   stripTerminalControlSequences
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-KJFGH23C.js";
 import {
   MAX_CHANNEL_DELIVERY_NAME_LENGTH,
   MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH
-} from "./chunk-F53KKZUD.js";
+} from "./chunk-3LMDSCLU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7BXXIQG4.js → chunk-ULPXHGLV.js}

@@ -1,18 +1,25 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  customDeepMerge,
+  getSettingsSchema
+} from "./chunk-5VPMGZ2V.js";
 import {
   DEFAULT_DARK_THEME_NAME,
   DEFAULT_LIGHT_THEME_NAME
 } from "./chunk-RKUWKYED.js";
 import {
-  customDeepMerge,
-  getSettingsSchema
-} from "./chunk-ZU47FBOC.js";
+  t
+} from "./chunk-I6YJZGHS.js";
+import {
+  SUPPORTED_LANGUAGES,
+  getLanguageNameFromLocale
+} from "./chunk-5EJZE3FP.js";
 import {
   getHomeEnvFallbackVars,
   loadEnvironment,
   preResolveHomeEnvOverrides
-} from "./chunk-NOAG7N22.js";
+} from "./chunk-3CEFQSKN.js";
 import {
   CONSOLIDATED_DISABLE_KEYS,
   V1_INDICATOR_KEYS,
@@ -20,25 +27,18 @@ import {
   V1_TO_V2_PRESERVE_DISABLE_MAP,
   V2_CONTAINER_KEYS
 } from "./chunk-BW4333PP.js";
-import {
-  ENV_CORRUPTED_PATH,
-  ENV_WAS_RECOVERED
-} from "./chunk-VX63RJXE.js";
 import {
   getSystemDefaultsPath,
   getSystemSettingsPath
 } from "./chunk-IDS7MSUP.js";
 import {
-  t
-} from "./chunk-VZUCTJ2P.js";
-import {
-  SUPPORTED_LANGUAGES,
-  getLanguageNameFromLocale
-} from "./chunk-5EJZE3FP.js";
+  ENV_CORRUPTED_PATH,
+  ENV_WAS_RECOVERED
+} from "./chunk-XX5HQLCZ.js";
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-53GWJOLP.js";
+} from "./chunk-F7WDCD2N.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
@@ -47,7 +47,7 @@ import {
 } from "./chunk-65I7S4Z3.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-ZTTC7T4X.js";
+} from "./chunk-JPXPY5L4.js";
 import {
   FatalConfigError,
   Storage,
@@ -64,7 +64,7 @@ import {
 
 // packages/cli/src/config/settings.ts
 init_esbuild_shims();
-import * as fs3 from "node:fs";
+import * as fs2 from "node:fs";
 import * as path2 from "node:path";
 import { homedir } from "node:os";
 import process from "node:process";
@@ -109,7 +109,6 @@ __name(getOwnKeyScope, "getOwnKeyScope");
 
 // packages/cli/src/config/settingsUtils.ts
 init_esbuild_shims();
-import * as fs2 from "node:fs";
 
 // packages/cli/src/i18n/languageUtils.ts
 init_esbuild_shims();
@@ -364,6 +363,7 @@ __name(getAllSettingKeys, "getAllSettingKeys");
 var SETTINGS_DIALOG_ORDER = [
   // Workflow Control - most impactful setting
   "tools.approvalMode",
+  "tools.codeModeOnly",
   // Localization - users often set this first
   "general.language",
   "general.outputLanguage",
@@ -377,6 +377,7 @@ var SETTINGS_DIALOG_ORDER = [
   "ide.enabled",
   "ui.showLineNumbers",
   "ui.hideTips",
+  "ui.showToolCallDetails",
   "general.terminalBell",
   "ui.enableWelcomeBack",
   // Git Behavior
@@ -432,6 +433,11 @@ function validateSettingValue(def, value) {
     default:
       return `Settings of type '${def.type}' cannot be modified via this API`;
   }
+  if ((typeof value === "string" || typeof value === "number") && // `includes` is SameValueZero, so a `[0]` exclusion also catches the `-0`
+  // that `Number('-0')` produces and `JSON.stringify` would persist as `0`.
+  def.excludedValues?.includes(value)) {
+    return `Value must not be ${String(value)}`;
+  }
   return void 0;
 }
 __name(validateSettingValue, "validateSettingValue");
@@ -634,45 +640,6 @@ function isDefaultValue(key, settings) {
   return !settingExistsInScope(key, settings);
 }
 __name(isDefaultValue, "isDefaultValue");
-function backupSettingsFile(filePath) {
-  try {
-    if (fs2.existsSync(filePath)) {
-      const backupPath = `${filePath}.orig`;
-      fs2.copyFileSync(filePath, backupPath);
-      return true;
-    }
-  } catch (_e) {
-  }
-  return false;
-}
-__name(backupSettingsFile, "backupSettingsFile");
-function restoreSettingsFromBackup(filePath) {
-  try {
-    const backupPath = `${filePath}.orig`;
-    if (fs2.existsSync(backupPath)) {
-      fs2.copyFileSync(backupPath, filePath);
-      fs2.unlinkSync(backupPath);
-      return true;
-    }
-  } catch (err) {
-    console.error(
-      `[settingsUtils] restoreSettingsFromBackup(${filePath}) failed:`,
-      err
-    );
-  }
-  return false;
-}
-__name(restoreSettingsFromBackup, "restoreSettingsFromBackup");
-function cleanupSettingsBackup(filePath) {
-  try {
-    const backupPath = `${filePath}.orig`;
-    if (fs2.existsSync(backupPath)) {
-      fs2.unlinkSync(backupPath);
-    }
-  } catch (_e) {
-  }
-}
-__name(cleanupSettingsBackup, "cleanupSettingsBackup");
 
 // packages/cli/src/config/migration/index.ts
 init_esbuild_shims();
@@ -1643,14 +1610,14 @@ var LoadedSettings = class {
     }
     let reloaded = false;
     try {
-      if (!fs3.existsSync(file.path)) {
+      if (!fs2.existsSync(file.path)) {
         file.settings = {};
         file.originalSettings = {};
         file.rawJson = void 0;
         this._merged = this.computeMergedSettings();
         return true;
       }
-      const content = fs3.readFileSync(file.path, "utf-8");
+      const content = fs2.readFileSync(file.path, "utf-8");
       const parsed = JSON.parse((0, import_strip_json_comments.default)(content));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const resolved = resolveEnvVarsInObject(
@@ -1748,11 +1715,11 @@ function detectQwenHomeRedirectWithoutMigration(activeUserSettingsPath) {
   if (path2.resolve(activeQwenDir) === path2.resolve(legacyQwenDir)) {
     return null;
   }
-  if (fs3.existsSync(activeUserSettingsPath)) {
+  if (fs2.existsSync(activeUserSettingsPath)) {
     return null;
   }
   const legacyUserSettings = path2.join(legacyQwenDir, "settings.json");
-  if (!fs3.existsSync(legacyUserSettings)) {
+  if (!fs2.existsSync(legacyUserSettings)) {
     return null;
   }
   return `QWEN_HOME points to "${activeQwenDir}" but no settings.json was found there. Existing config remains at "${legacyQwenDir}" \u2014 OAuth tokens, settings, memory, extensions, and skills are not auto-migrated. Copy them manually if you want them to apply at the new location.`;
@@ -1776,17 +1743,17 @@ function loadSettings(workspaceDir = process.cwd(), consumeCorruptionEnvVars = t
   const resolvedHomeDir = path2.resolve(homedir());
   let realWorkspaceDir = resolvedWorkspaceDir;
   try {
-    realWorkspaceDir = fs3.realpathSync(resolvedWorkspaceDir);
+    realWorkspaceDir = fs2.realpathSync(resolvedWorkspaceDir);
   } catch (_e) {
   }
-  const realHomeDir = fs3.realpathSync(resolvedHomeDir);
+  const realHomeDir = fs2.realpathSync(resolvedHomeDir);
   const workspaceSettingsPath = new Storage(
     workspaceDir
   ).getWorkspaceSettingsPath();
   const loadAndMigrate = /* @__PURE__ */ __name((filePath, scope) => {
     try {
-      if (fs3.existsSync(filePath)) {
-        const content = fs3.readFileSync(filePath, "utf-8");
+      if (fs2.existsSync(filePath)) {
+        const content = fs2.readFileSync(filePath, "utf-8");
         let rawSettings;
         const corruptedPath = `${filePath}${CORRUPTED_SUFFIX}`;
         let corruptedSaved = false;
@@ -1798,7 +1765,7 @@ function loadSettings(workspaceDir = process.cwd(), consumeCorruptionEnvVars = t
             `Settings file ${filePath} has invalid JSON (${getErrorMessage(parseError)}). Resetting to empty settings.`
           );
           try {
-            fs3.copyFileSync(filePath, corruptedPath);
+            fs2.copyFileSync(filePath, corruptedPath);
             corruptedSaved = true;
           } catch (copyError) {
             debugLogger2.warn(
@@ -1810,7 +1777,7 @@ function loadSettings(workspaceDir = process.cwd(), consumeCorruptionEnvVars = t
             debugLogger2.warn(warningMsg);
             if (corruptedSaved) {
               try {
-                fs3.writeFileSync(filePath, "{}", "utf-8");
+                fs2.writeFileSync(filePath, "{}", "utf-8");
               } catch {
               }
             }
@@ -2023,8 +1990,8 @@ __name(createSettingsUpdate, "createSettingsUpdate");
 function saveSettings(settingsFile, updates = settingsFile.originalSettings, replacePath = [], opts = {}) {
   try {
     const dirPath = path2.dirname(settingsFile.path);
-    if (!fs3.existsSync(dirPath)) {
-      fs3.mkdirSync(dirPath, { recursive: true });
+    if (!fs2.existsSync(dirPath)) {
+      fs2.mkdirSync(dirPath, { recursive: true });
     }
     const written = updateSettingsFilePreservingFormat(
       settingsFile.path,
@@ -2079,9 +2046,6 @@ export {
   getDisplayValue,
   nextBooleanSettingValue,
   isDefaultValue,
-  backupSettingsFile,
-  restoreSettingsFromBackup,
-  cleanupSettingsBackup,
   v1ToV2Migration,
   getUserSettingsPath,
   getUserSettingsDir,

package/chunks/{chunk-5KI7ZDTB.js → chunk-UN6YL6VF.js}

@@ -3,28 +3,33 @@
 import {
   buildModelReasoningConfigPreview,
   resolvePersistedReasoningConfigState
-} from "./chunk-BV6Q5HMY.js";
+} from "./chunk-MJHLKWGJ.js";
+import {
+  getModelConfigurationKey
+} from "./chunk-LAKMZLJ5.js";
+import {
+  snapshotProcessEnv
+} from "./chunk-VRQZESKP.js";
+import {
+  STATUS_SCHEMA_VERSION
+} from "./chunk-54B2LTKP.js";
+import {
+  getAuthTypeFromEnv,
+  resolveCliGenerationConfig
+} from "./chunk-L63PZHD7.js";
 import {
   ACP_ROUTE_ID_PREFIX,
   buildAcpModelOptions,
-  getAuthTypeFromEnv,
   getCurrentAcpModelId,
   parseAcpBaseModelId,
-  resolveCliGenerationConfig,
   sanitizeProviderBaseUrl
-} from "./chunk-MF6E7FSA.js";
-import {
-  snapshotProcessEnv
-} from "./chunk-TBEXLLAO.js";
-import {
-  STATUS_SCHEMA_VERSION
-} from "./chunk-HGEUHUEV.js";
+} from "./chunk-INGBUYL6.js";
 import {
   loadSettings
-} from "./chunk-7BXXIQG4.js";
+} from "./chunk-ULPXHGLV.js";
 import {
   ModelsConfig
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-JPXPY5L4.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";
@@ -141,7 +146,14 @@ function buildWorkspaceProvidersStatus(workspaceCwd, acpChannelLive, options) {
           baseUrl: resolved.baseUrl
         } : void 0
       );
+      const configurationKey = getModelConfigurationKey(
+        loaded,
+        authType,
+        model.id,
+        model.registryBaseUrl
+      );
       const providerModel = {
+        ...configurationKey ? { configurationKey } : {},
         modelId,
         baseModelId: parseAcpBaseModelId(effectiveModelId),
         name: model.label,

package/chunks/{chunk-JXNIF2O5.js → chunk-V545KI73.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   isTool
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-VGY2RGXL.js

@@ -0,0 +1,100 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  redactProxyCredentials
+} from "./chunk-EWJTAP3Y.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/responses-http-error.ts
+init_esbuild_shims();
+var ResponsesHttpError = class extends Error {
+  constructor(status, body, responseHeaders, secrets = []) {
+    const sanitize = /* @__PURE__ */ __name((value) => {
+      let text = redactProxyCredentials(value);
+      for (const secret of secrets) {
+        if (secret) text = text.split(secret).join("<redacted>");
+      }
+      return text;
+    }, "sanitize");
+    const headers = new Headers();
+    for (const name of [
+      "x-request-id",
+      "retry-after",
+      "retry-after-ms",
+      "x-should-retry"
+    ]) {
+      const value = responseHeaders?.get(name);
+      if (value) headers.set(name, sanitize(value));
+    }
+    let envelope;
+    try {
+      envelope = record(JSON.parse(body));
+    } catch {
+    }
+    const gateway = record(envelope?.["routify_response"]);
+    const upstream = record(envelope?.["error"]) ?? record(record(gateway?.["error_detail"])?.["error"]);
+    const error = {};
+    for (const name of ["message", "code", "type", "param"]) {
+      const value = upstream?.[name];
+      if (typeof value === "string" || typeof value === "number") {
+        error[name] = sanitize(String(value));
+      }
+    }
+    const requestId = headers.get("x-request-id") ?? (string(gateway?.["request_id"]) ? sanitize(String(gateway["request_id"])) : void 0);
+    const diagnostic = {
+      ...Object.keys(error).length ? { error } : {},
+      ...requestId ? { request_id: requestId } : {},
+      ...string(gateway?.["trace_id"]) ? { trace_id: sanitize(String(gateway["trace_id"])) } : {},
+      ...string(gateway?.["model_name"]) ? { model_name: sanitize(String(gateway["model_name"])) } : {}
+    };
+    const excerpt = Object.keys(error).length ? JSON.stringify(diagnostic) : sanitize(body).substring(0, 500);
+    super(
+      `Responses API error ${status}: ${excerpt}` + (!Object.keys(error).length && requestId ? ` (request_id: ${requestId})` : "")
+    );
+    this.status = status;
+    this.name = "ResponsesHttpError";
+    this.headers = headers;
+    this.requestId = requestId;
+    this.error = Object.keys(error).length ? error : void 0;
+    this.code = error["code"];
+    this.type = error["type"];
+    this.param = error["param"];
+  }
+  static {
+    __name(this, "ResponsesHttpError");
+  }
+  headers;
+  requestId;
+  code;
+  type;
+  param;
+  error;
+  shouldRetry(extraRetryErrorCodes) {
+    const directive = this.headers.get("x-should-retry");
+    if (directive === "true") return true;
+    if (directive === "false") return false;
+    return this.status === 408 || this.status === 409 || this.status === 429 || this.status >= 500 && this.status < 600 || (extraRetryErrorCodes?.includes(this.status) ?? false);
+  }
+};
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+__name(record, "record");
+function string(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+__name(string, "string");
+
+export {
+  ResponsesHttpError
+};
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */