@qwen-code/qwen-code 0.21.6 → 0.21.7

package/chunks/{chunk-W5DXUTXD.js → chunk-6XJMFJ4D.js}

@@ -1,11 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  formatHistoryGapNotice
+} from "./chunk-KXSDEOFU.js";
 import {
   sanitizeTerminalText
 } from "./chunk-4NFY2S7N.js";
-import {
-  formatHistoryGapNotice
-} from "./chunk-RFUHDCNF.js";
 import {
   isGoalStatusKind,
   isTerminalGoalStatusKind
@@ -19,18 +19,18 @@ import {
   setGoalTerminalObserver,
   setLastGoalTerminal,
   unregisterGoalHook
-} from "./chunk-A4VTILZT.js";
+} from "./chunk-Y7E5LNLO.js";
 import {
   apiActivityTracker,
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-PX5DNLSA.js";
+} from "./chunk-2U3WZGZG.js";
 import {
   ToolNames
-} from "./chunk-D7D7RXIJ.js";
+} from "./chunk-IC4Z6LX6.js";
 import {
   createDebugLogger
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -2869,7 +2869,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./deferred-core-runtime-QWAEBTR5.js");
+    const { getGitRepoName } = await import("./deferred-core-runtime-BWRCCFTE.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;

package/chunks/{chunk-ACZRB7AD.js → chunk-6XU3PH66.js}

@@ -10,19 +10,19 @@ import {
 } from "./chunk-MR3PXB6E.js";
 import {
   ideContextStore
-} from "./chunk-A4VTILZT.js";
+} from "./chunk-Y7E5LNLO.js";
 import {
   require_proper_lockfile
 } from "./chunk-KRXPRVGL.js";
 import {
   atomicWriteFileSync
-} from "./chunk-UH7Z7Y45.js";
+} from "./chunk-FOGU3LJX.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger,
   getErrorMessage
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   writeStderrLine
 } from "./chunk-KGJGEEVR.js";

package/chunks/{chunk-NGJOAKJY.js → chunk-72LNFGUY.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-GESMMPAK.js";
+} from "./chunk-RUL4S3K3.js";
 import {
   parseAndFormatApiError
-} from "./chunk-A4VTILZT.js";
+} from "./chunk-Y7E5LNLO.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-PX5DNLSA.js";
+} from "./chunk-2U3WZGZG.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-33FNCQSY.js → chunk-7MH4J33A.js}

@@ -10,11 +10,11 @@ import {
 } from "./chunk-CPBF7KYF.js";
 import {
   atomicWriteJSON
-} from "./chunk-UH7Z7Y45.js";
+} from "./chunk-FOGU3LJX.js";
 import {
   Storage,
   isNodeError
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-2AGOQ7QO.js → chunk-7UFKAV7Y.js}

@@ -1,8 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  MAX_INLINE_IMAGE_ENCODED_LENGTH
+} from "./chunk-2VSTGY6M.js";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-D7D7RXIJ.js";
+} from "./chunk-IC4Z6LX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -847,11 +850,15 @@ var MAX_PREVIEW_ROWS = 24;
 var ESTIMATED_CELL_WIDTH_PX = 8;
 var ESTIMATED_CELL_HEIGHT_PX = 16;
 var MAX_REASON_CHARS = 200;
+var MAX_INLINE_IMAGE_DIMENSION = 1e6;
+var MAX_INLINE_IMAGE_PIXELS = 64e6;
 var CMD_SHELL_METACHARACTERS = /[&|<>^%"!()\n\r]/;
 var RENDER_CACHE_LIMIT = 40;
 var RENDER_CACHE_BYTE_LIMIT = 32 * 1024 * 1024;
 var renderCache = /* @__PURE__ */ new Map();
 var renderCacheBytes = 0;
+var INLINE_DECODE_CACHE_LIMIT = 4;
+var inlineDecodeCache = /* @__PURE__ */ new Map();
 var TRANSMITTED_KEY_LIMIT = 256;
 var transmittedKeys = /* @__PURE__ */ new Set();
 function wasKittyImageWritten(key) {
@@ -896,6 +903,44 @@ function containsCmdShellMetacharacters(filePath) {
   return CMD_SHELL_METACHARACTERS.test(filePath);
 }
 __name(containsCmdShellMetacharacters, "containsCmdShellMetacharacters");
+function prepareInlineTerminalImage({
+  data,
+  mimeType,
+  contentWidth,
+  availableTerminalHeight,
+  env = process.env,
+  stdoutIsTTY = process.stdout.isTTY,
+  disabled = false
+}) {
+  const format = getImageFormat(mimeType);
+  const emptyFallback = format ? `[image: ${format}]` : "[image]";
+  if (format !== "png") {
+    return { fallbackText: emptyFallback, result: null };
+  }
+  const decoded = getDecodedInlinePng(data);
+  if (!decoded) {
+    return { fallbackText: emptyFallback, result: null };
+  }
+  const { png, size } = decoded;
+  const fallbackText = `[image: ${size.width}x${size.height} png]`;
+  if (disabled) {
+    return { fallbackText, result: null };
+  }
+  const shape = fitImageToTerminal2(size, contentWidth, availableTerminalHeight);
+  const useKitty = supportsKittyImageProtocol(env, stdoutIsTTY);
+  const chafaPath = useKitty ? null : findExecutable("chafa", env);
+  const cacheKey = createInlineRenderCacheKey(png, shape, useKitty, chafaPath);
+  const cached = getCachedRenderResult(cacheKey);
+  if (cached) {
+    return { fallbackText, result: cached };
+  }
+  const result = useKitty ? { ...renderKitty(png, shape), key: cacheKey } : renderWithChafa({ data: png }, shape, env, chafaPath);
+  if (result.kind !== "unavailable") {
+    rememberRenderResult(cacheKey, result);
+  }
+  return { fallbackText, result };
+}
+__name(prepareInlineTerminalImage, "prepareInlineTerminalImage");
 function renderTerminalImage({
   display,
   contentWidth,
@@ -959,7 +1004,7 @@ function renderTerminalImage({
       reason: `Image exceeds the ${MAX_TERMINAL_IMAGE_BYTES} byte display limit.`
     };
   }
-  const result = useKitty ? { ...renderKitty(png, shape), key: cacheKey } : renderWithChafa(display.filePath, shape, env, chafaPath);
+  const result = useKitty ? { ...renderKitty(png, shape), key: cacheKey } : renderWithChafa({ filePath: display.filePath }, shape, env, chafaPath);
   if (result.kind !== "unavailable") {
     rememberRenderResult(cacheKey, result);
   }
@@ -996,6 +1041,70 @@ function createRenderCacheKey(filePath, stat, shape, useKitty, chafaPath) {
   ].join("\0");
 }
 __name(createRenderCacheKey, "createRenderCacheKey");
+function createInlineRenderCacheKey(png, shape, useKitty, chafaPath) {
+  return [
+    "inline",
+    crypto2.createHash("sha256").update(png).digest("hex"),
+    shape.widthCells,
+    shape.rows,
+    useKitty ? "kitty" : chafaPath ?? "none"
+  ].join("\0");
+}
+__name(createInlineRenderCacheKey, "createInlineRenderCacheKey");
+function getImageFormat(mimeType) {
+  const match = /^image\/([a-z0-9][a-z0-9.+-]*)$/.exec(
+    mimeType.trim().toLowerCase()
+  );
+  return match?.[1] ?? null;
+}
+__name(getImageFormat, "getImageFormat");
+function decodeInlineImage(data) {
+  if (data.length === 0 || data.length > MAX_INLINE_IMAGE_ENCODED_LENGTH) {
+    return null;
+  }
+  const normalized = data.replace(/\s/g, "");
+  if (normalized.length === 0 || normalized.length % 4 === 1 || !/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
+    return null;
+  }
+  const decoded = Buffer.from(normalized, "base64");
+  if (decoded.length === 0 || decoded.length > MAX_TERMINAL_IMAGE_BYTES || decoded.toString("base64").replace(/=+$/, "") !== normalized.replace(/=+$/, "")) {
+    return null;
+  }
+  return decoded;
+}
+__name(decodeInlineImage, "decodeInlineImage");
+function getDecodedInlinePng(data) {
+  const cached = inlineDecodeCache.get(data);
+  if (cached) {
+    inlineDecodeCache.delete(data);
+    inlineDecodeCache.set(data, cached);
+    return cached;
+  }
+  const png = decodeInlineImage(data);
+  if (!png) return null;
+  const size = readValidatedInlinePngSize(png);
+  if (!size) return null;
+  const decoded = { png, size };
+  inlineDecodeCache.set(data, decoded);
+  while (inlineDecodeCache.size > INLINE_DECODE_CACHE_LIMIT) {
+    const oldest = inlineDecodeCache.keys().next().value;
+    if (oldest === void 0) break;
+    inlineDecodeCache.delete(oldest);
+  }
+  return decoded;
+}
+__name(getDecodedInlinePng, "getDecodedInlinePng");
+function readValidatedInlinePngSize(png) {
+  if (png.length < 24 || png.readUInt32BE(8) !== 13 || png.subarray(12, 16).toString("ascii") !== "IHDR") {
+    return null;
+  }
+  const size = readPngSize(png);
+  if (!size || !Number.isInteger(size.width) || !Number.isInteger(size.height) || size.width <= 0 || size.height <= 0 || size.width > MAX_INLINE_IMAGE_DIMENSION || size.height > MAX_INLINE_IMAGE_DIMENSION || size.width * size.height > MAX_INLINE_IMAGE_PIXELS) {
+    return null;
+  }
+  return size;
+}
+__name(readValidatedInlinePngSize, "readValidatedInlinePngSize");
 function getCachedRenderResult(key) {
   const cached = renderCache.get(key);
   if (cached) {
@@ -1097,7 +1206,7 @@ function renderKitty(png, shape) {
   };
 }
 __name(renderKitty, "renderKitty");
-function renderWithChafa(filePath, shape, env, chafaPath) {
+function renderWithChafa(source, shape, env, chafaPath) {
   if (!chafaPath) {
     return {
       kind: "unavailable",
@@ -1105,7 +1214,7 @@ function renderWithChafa(filePath, shape, env, chafaPath) {
     };
   }
   const useShell = shouldRunThroughShell(chafaPath);
-  if (useShell && containsCmdShellMetacharacters(filePath)) {
+  if (useShell && "filePath" in source && containsCmdShellMetacharacters(source.filePath)) {
     return {
       kind: "unavailable",
       reason: "Image path contains characters that cannot be safely passed to the renderer on this platform."
@@ -1120,14 +1229,15 @@ function renderWithChafa(filePath, shape, env, chafaPath) {
         "--format=symbols",
         "--symbols=block",
         `--size=${shape.widthCells}x${shape.rows}`,
-        filePath
+        "filePath" in source ? source.filePath : "-"
       ],
       {
         encoding: "utf8",
         env: createRendererChildEnv(env),
         shell: useShell,
         maxBuffer: CHAFA_MAX_OUTPUT_BYTES,
-        timeout: CHAFA_TIMEOUT_MS
+        timeout: CHAFA_TIMEOUT_MS,
+        ..."data" in source ? { input: source.data } : {}
       }
     );
     const lines = stdout.split(/\r?\n/).filter((line) => line.length > 0);
@@ -1150,12 +1260,14 @@ __name(firstLineBounded, "firstLineBounded");
 
 export {
   renderMermaidImageAsync,
+  MAX_INLINE_IMAGE_PIXELS,
   TRANSMITTED_KEY_LIMIT,
   wasKittyImageWritten,
   markKittyImageWritten,
   supportsKittyImageProtocol,
   getTerminalImageRenderSupport,
   containsCmdShellMetacharacters,
+  prepareInlineTerminalImage,
   renderTerminalImage
 };
 /**

package/chunks/{chunk-O7V7N4G7.js → chunk-AE77C5ZU.js}

@@ -5,14 +5,14 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-C4CBJQKY.js";
+} from "./chunk-55LYDVPU.js";
 import {
   resolvePath
-} from "./chunk-JELIWHXD.js";
+} from "./chunk-AOHJKPKL.js";
 import {
   createDebugLogger,
   isSubpath
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -24,7 +24,7 @@ import {
 init_esbuild_shims();
 import process from "node:process";
 import { lookup as dnsLookup } from "node:dns/promises";
-import { isIP } from "node:net";
+import { BlockList, isIP } from "node:net";
 
 // packages/cli/src/services/voice-keyterms.ts
 init_esbuild_shims();
@@ -238,6 +238,14 @@ var MIN_KEYTERM_ECHO_TOKENS = 8;
 var MIN_ABSOLUTE_KEYTERM_ECHO_TOKENS = 10;
 var MIN_KEYTERM_SET_ECHO_RATIO = 0.3;
 var debugLogger = createDebugLogger("VOICE_TRANSCRIBER");
+var BLOCKED_TRANSITION_IPV6_ADDRESSES = new BlockList();
+for (const [address, prefix] of [
+  ["64:ff9b:1::", 48],
+  ["2001::", 23],
+  ["2002::", 16]
+]) {
+  BLOCKED_TRANSITION_IPV6_ADDRESSES.addSubnet(address, prefix, "ipv6");
+}
 function trimTrailingSlashes(value) {
   return value.replace(/\/+$/, "");
 }
@@ -264,35 +272,78 @@ function normalizeBaseUrl(baseUrl, modelName) {
   } catch {
     throw new Error(`Voice model '${modelName}' has an invalid baseUrl.`);
   }
-  url.username = "";
-  url.password = "";
+  if (url.username || url.password) {
+    throw new Error(
+      `Voice model '${modelName}' baseUrl must not contain embedded credentials.`
+    );
+  }
   return trimTrailingSlashes(url.toString());
 }
 __name(normalizeBaseUrl, "normalizeBaseUrl");
+function normalizeAllowedVoiceBaseUrl(baseUrl) {
+  try {
+    const url = new URL(baseUrl.trim());
+    if (url.username || url.password) {
+      return void 0;
+    }
+    return trimTrailingSlashes(url.toString());
+  } catch {
+    return void 0;
+  }
+}
+__name(normalizeAllowedVoiceBaseUrl, "normalizeAllowedVoiceBaseUrl");
+function isInsecureVoiceBaseUrlAllowed(settings, normalizedBaseUrl) {
+  const allowed = settings.merged.security?.allowedInsecureVoiceBaseUrls;
+  return Array.isArray(allowed) && allowed.some(
+    (candidate) => typeof candidate === "string" && normalizeAllowedVoiceBaseUrl(candidate) === normalizedBaseUrl
+  );
+}
+__name(isInsecureVoiceBaseUrlAllowed, "isInsecureVoiceBaseUrlAllowed");
 function normalizeHostname(hostname) {
   return hostname.toLowerCase().replace(/^\[|\]$/g, "");
 }
 __name(normalizeHostname, "normalizeHostname");
+function normalizeIpAddress(address) {
+  const host = normalizeHostname(address);
+  if (isIP(host) !== 6) {
+    return host;
+  }
+  try {
+    return normalizeHostname(new URL(`http://[${host}]/`).hostname);
+  } catch {
+    return host;
+  }
+}
+__name(normalizeIpAddress, "normalizeIpAddress");
 function isLoopbackHost(hostname) {
   const host = normalizeHostname(hostname);
   return host === "localhost" || host === "127.0.0.1" || host === "::1";
 }
 __name(isLoopbackHost, "isLoopbackHost");
+function isAwsIpv6MetadataAddress(hostname) {
+  const host = normalizeHostname(hostname);
+  if (isIP(host) !== 6) {
+    return false;
+  }
+  try {
+    return normalizeHostname(new URL(`http://[${host}]/`).hostname) === "fd00:ec2::254";
+  } catch {
+    return false;
+  }
+}
+__name(isAwsIpv6MetadataAddress, "isAwsIpv6MetadataAddress");
 function readIpv4CompatibleIpv6(host) {
   if (!host.startsWith("::") || host.startsWith("::ffff:")) {
     return void 0;
   }
   const parts = host.slice(2).split(":");
-  if (parts.length === 0 || parts.length > 2 || parts.some((p) => !p)) {
+  if (parts.length === 0 || parts.length > 2 || parts.some((part) => !part)) {
     return void 0;
   }
   if (parts.some((part) => !/^[0-9a-f]{1,4}$/i.test(part))) {
     return void 0;
   }
   const hextets = parts.map((part) => Number.parseInt(part, 16));
-  if (hextets.some((part) => !Number.isInteger(part) || part < 0 || part > 65535)) {
-    return void 0;
-  }
   const value = hextets.length === 1 ? hextets[0] : hextets[0] << 16 | hextets[1];
   return [
     value >>> 24 & 255,
@@ -302,39 +353,130 @@ function readIpv4CompatibleIpv6(host) {
   ].join(".");
 }
 __name(readIpv4CompatibleIpv6, "readIpv4CompatibleIpv6");
-function isPrivateNetworkIp(hostname) {
-  const host = normalizeHostname(hostname);
-  if (isLoopbackHost(host)) {
-    return false;
+function readIpv4MappedIpv6(host) {
+  const dotted = host.match(/^::ffff:(\d+(?:\.\d+){3})$/i);
+  if (dotted && isIP(dotted[1]) === 4) {
+    return dotted[1];
   }
-  const ipv4Mapped = host.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  const hex = host.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
+  if (!hex) {
+    return void 0;
+  }
+  return readIpv4HexPair(hex[1], hex[2]);
+}
+__name(readIpv4MappedIpv6, "readIpv4MappedIpv6");
+function readIpv4HexPair(highHex, lowHex) {
+  const high = Number.parseInt(highHex, 16);
+  const low = Number.parseInt(lowHex, 16);
+  return [high >>> 8, high & 255, low >>> 8, low & 255].join(".");
+}
+__name(readIpv4HexPair, "readIpv4HexPair");
+function readWellKnownNat64Ipv6(host) {
+  const prefix = "64:ff9b::";
+  if (!host.startsWith(prefix)) {
+    return void 0;
+  }
+  const suffix = host.slice(prefix.length);
+  if (!suffix) {
+    return "0.0.0.0";
+  }
+  const groups = suffix.split(":");
+  if (groups.length > 2 || groups.some((group) => !/^[0-9a-f]{1,4}$/i.test(group))) {
+    return void 0;
+  }
+  return groups.length === 1 ? readIpv4HexPair("0", groups[0]) : readIpv4HexPair(groups[0], groups[1]);
+}
+__name(readWellKnownNat64Ipv6, "readWellKnownNat64Ipv6");
+function isBlockedTransitionIpv6Address(host) {
+  return isIP(host) === 6 && BLOCKED_TRANSITION_IPV6_ADDRESSES.check(host, "ipv6");
+}
+__name(isBlockedTransitionIpv6Address, "isBlockedTransitionIpv6Address");
+function unwrapIpv6TransitionStep(host) {
+  const ipv4Mapped = readIpv4MappedIpv6(host);
   if (ipv4Mapped) {
-    return isPrivateNetworkIp(ipv4Mapped[1]);
+    return { address: ipv4Mapped };
   }
-  const ipv4Compatible = host.match(/^::(\d+\.\d+\.\d+\.\d+)$/);
+  const ipv4Compatible = readIpv4CompatibleIpv6(host);
   if (ipv4Compatible) {
-    return isPrivateNetworkIp(ipv4Compatible[1]);
+    return { address: ipv4Compatible };
   }
-  const normalizedIpv4Compatible = readIpv4CompatibleIpv6(host);
-  if (normalizedIpv4Compatible) {
-    return isPrivateNetworkIp(normalizedIpv4Compatible);
+  const nat64 = readWellKnownNat64Ipv6(host);
+  if (nat64) {
+    return { address: nat64 };
   }
   if (host.startsWith("::ffff:")) {
+    return "blocked";
+  }
+  return void 0;
+}
+__name(unwrapIpv6TransitionStep, "unwrapIpv6TransitionStep");
+function isPrivateNetworkIp(hostname) {
+  const host = normalizeIpAddress(hostname);
+  if (isBlockedTransitionIpv6Address(host)) {
     return true;
   }
+  if (isLoopbackHost(host)) {
+    return false;
+  }
+  const step = unwrapIpv6TransitionStep(host);
+  if (step === "blocked") {
+    return true;
+  }
+  if (step) {
+    return isPrivateNetworkIp(step.address);
+  }
   if (isIP(host) === 4) {
     const [first = 0, second = 0] = host.split(".").map(Number);
     return first === 0 || first === 10 || first === 127 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168 || first === 100 && second >= 64 && second <= 127;
   }
   if (isIP(host) === 6) {
-    const firstHextet = Number.parseInt(host.split(":", 1)[0] || "", 16);
-    const isLinkLocal = firstHextet >= 65152 && firstHextet <= 65215;
-    const isUniqueLocal = (firstHextet & 65024) === 64512;
-    return host === "::" || isLinkLocal || isUniqueLocal;
+    const firstHextet = Number.parseInt(host.split(":", 1)[0] || "0", 16);
+    return host === "::" || (firstHextet & 65472) === 65152 || (firstHextet & 65024) === 64512;
   }
   return false;
 }
 __name(isPrivateNetworkIp, "isPrivateNetworkIp");
+function isAlwaysBlockedVoiceAddress(address) {
+  const host = normalizeIpAddress(address);
+  if (isBlockedTransitionIpv6Address(host)) {
+    return true;
+  }
+  if (isLoopbackHost(host)) {
+    return true;
+  }
+  const step = unwrapIpv6TransitionStep(host);
+  if (step === "blocked") {
+    return true;
+  }
+  if (step) {
+    return isAlwaysBlockedVoiceAddress(step.address);
+  }
+  if (isIP(host) === 4) {
+    const [first = 0, second = 0] = host.split(".").map(Number);
+    return first === 0 || first === 127 || first === 169 && second === 254 || host === "100.100.100.200";
+  }
+  if (isIP(host) === 6) {
+    const firstHextet = Number.parseInt(host.split(":", 1)[0] || "0", 16);
+    return host === "::" || isAwsIpv6MetadataAddress(host) || (firstHextet & 65472) === 65152;
+  }
+  return false;
+}
+__name(isAlwaysBlockedVoiceAddress, "isAlwaysBlockedVoiceAddress");
+function isLoopbackVoiceAddress(address) {
+  const host = normalizeIpAddress(address);
+  if (isLoopbackHost(host)) {
+    return true;
+  }
+  const step = unwrapIpv6TransitionStep(host);
+  if (step && step !== "blocked") {
+    return isLoopbackVoiceAddress(step.address);
+  }
+  if (isIP(host) === 4) {
+    return host.startsWith("127.");
+  }
+  return false;
+}
+__name(isLoopbackVoiceAddress, "isLoopbackVoiceAddress");
 async function defaultLookupHost(hostname) {
   return dnsLookup(hostname, { all: true });
 }
@@ -345,9 +487,9 @@ async function assertVoiceBaseUrlNetworkAllowed(voiceConfig, lookupHost, abortSi
     return;
   }
   if (isIP(hostname) !== 0) {
-    if (isPrivateNetworkIp(hostname)) {
+    if (isAlwaysBlockedVoiceAddress(hostname) || !voiceConfig.allowInsecureBaseUrl && isPrivateNetworkIp(hostname)) {
       throw new Error(
-        `Voice model '${voiceConfig.model}' resolved to a private-network address.`
+        isLoopbackVoiceAddress(hostname) ? `Voice model '${voiceConfig.model}' uses a loopback address outside the accepted spellings. To use a local ASR endpoint, set the baseUrl to http://localhost, http://127.0.0.1, or http://[::1].` : `Voice model '${voiceConfig.model}' resolved to a private-network address.`
       );
     }
     return;
@@ -378,9 +520,13 @@ async function assertVoiceBaseUrlNetworkAllowed(voiceConfig, lookupHost, abortSi
     if (onAbort) abortSignal?.removeEventListener("abort", onAbort);
   }
   const records = Array.isArray(result) ? result : [result];
-  if (records.some((record) => isPrivateNetworkIp(record.address))) {
+  if (records.some(
+    (record) => isAlwaysBlockedVoiceAddress(record.address) || !voiceConfig.allowInsecureBaseUrl && isPrivateNetworkIp(record.address)
+  )) {
     throw new Error(
-      `Voice model '${voiceConfig.model}' resolved to a private-network address.`
+      records.some((record) => isLoopbackVoiceAddress(record.address)) ? `Voice model '${voiceConfig.model}' resolved to a loopback address. Loopback DNS results are always blocked; to use a local ASR endpoint, configure an explicit loopback baseUrl: http://localhost, http://127.0.0.1, or http://[::1].` : voiceConfig.allowInsecureBaseUrl && records.some(
+        (record) => isAlwaysBlockedVoiceAddress(record.address)
+      ) ? `Voice model '${voiceConfig.model}' resolved to an address that is always blocked (metadata, link-local, or transition range), even when the baseUrl is listed in security.allowedInsecureVoiceBaseUrls.` : `Voice model '${voiceConfig.model}' resolved to a private-network address.`
     );
   }
 }
@@ -390,7 +536,8 @@ function readApiKey(settings, model, baseUrl, env) {
     return void 0;
   }
   const envKey = model.envKey ?? DEFAULT_OPENAI_API_KEY;
-  const envValue = (env ?? process.env)[envKey];
+  const envSource = env ?? process.env;
+  const envValue = Object.hasOwn(envSource, envKey) ? envSource[envKey] : void 0;
   if (envValue && envValue.trim().length > 0) {
     return envValue.trim();
   }
@@ -431,14 +578,28 @@ function resolveVoiceTranscriptionConfig({
   const normalizedBaseUrl = normalizeBaseUrl(baseUrl, voiceModel);
   const parsedBaseUrl = new URL(normalizedBaseUrl);
   const isLocalhost = isLoopbackHost(parsedBaseUrl.hostname);
-  if (parsedBaseUrl.protocol !== "https:" && !isLocalhost) {
+  const allowInsecureBaseUrl = isInsecureVoiceBaseUrlAllowed(
+    settings,
+    normalizedBaseUrl
+  );
+  if (parsedBaseUrl.protocol !== "http:" && parsedBaseUrl.protocol !== "https:") {
+    throw new Error(
+      `Voice model '${voiceModel}' must use an http or https baseUrl.`
+    );
+  }
+  if (!isLocalhost && isAlwaysBlockedVoiceAddress(parsedBaseUrl.hostname)) {
+    throw new Error(
+      isLoopbackVoiceAddress(parsedBaseUrl.hostname) ? `Voice model '${voiceModel}' uses a loopback address outside the accepted spellings. To use a local ASR endpoint, set the baseUrl to http://localhost, http://127.0.0.1, or http://[::1].` : `Voice model '${voiceModel}' must not use a private-network baseUrl.`
+    );
+  }
+  if (parsedBaseUrl.protocol !== "https:" && !isLocalhost && !allowInsecureBaseUrl) {
     throw new Error(
-      `Voice model '${voiceModel}' must use an https baseUrl. Voice audio must not be transmitted in cleartext.`
+      `Voice model '${voiceModel}' must use an https baseUrl. Voice audio must not be transmitted in cleartext. To trust this managed endpoint, add its exact complete normalized URL (${normalizedBaseUrl}) to security.allowedInsecureVoiceBaseUrls. This setting is only honored from User, System, or SystemDefaults scope settings; Workspace entries are ignored.`
     );
   }
-  if (isPrivateNetworkIp(parsedBaseUrl.hostname)) {
+  if (!isLocalhost && !allowInsecureBaseUrl && isPrivateNetworkIp(parsedBaseUrl.hostname)) {
     throw new Error(
-      `Voice model '${voiceModel}' must not use a private-network baseUrl.`
+      `Voice model '${voiceModel}' must not use a private-network baseUrl. To trust this managed endpoint, add its exact complete normalized URL (${normalizedBaseUrl}) to security.allowedInsecureVoiceBaseUrls. This setting is only honored from User, System, or SystemDefaults scope settings; Workspace entries are ignored.`
     );
   }
   const apiKey = readApiKey(settings, model, normalizedBaseUrl, env);
@@ -448,7 +609,8 @@ function resolveVoiceTranscriptionConfig({
   return {
     model: voiceModel,
     baseUrl: normalizedBaseUrl,
-    ...apiKey ? { apiKey } : {}
+    ...apiKey ? { apiKey } : {},
+    ...allowInsecureBaseUrl ? { allowInsecureBaseUrl: true } : {}
   };
 }
 __name(resolveVoiceTranscriptionConfig, "resolveVoiceTranscriptionConfig");
@@ -472,6 +634,7 @@ function resolveVoiceStreamConfig(args) {
     baseUrl: base.baseUrl,
     model: base.model,
     ...base.apiKey ? { apiKey: base.apiKey } : {},
+    ...base.allowInsecureBaseUrl ? { allowInsecureBaseUrl: true } : {},
     ...language ? { language } : {},
     ...keytermsContext ? { keytermsContext } : {}
   };

package/chunks/{chunk-JELIWHXD.js → chunk-AOHJKPKL.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   expandHomeDir
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";