@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260630.e00fe6a27

package/chunks/chunk-HFQ2XSE7.js

@@ -0,0 +1,690 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  formatUnsupportedVoiceModelMessage,
+  isTranscribableVoiceModel,
+  readVoiceLanguage,
+  resolveVoiceTransport
+} from "./chunk-5XQ4A26L.js";
+import {
+  resolvePath
+} from "./chunk-BC3C4F3Q.js";
+import {
+  createDebugLogger,
+  isSubpath
+} from "./chunk-UX4SGCGN.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/services/voice-transcriber.ts
+init_esbuild_shims();
+import process from "node:process";
+import { lookup as dnsLookup } from "node:dns/promises";
+import { isIP } from "node:net";
+
+// packages/cli/src/services/voice-keyterms.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var GLOBAL_KEYTERMS = [
+  "Qwen",
+  "MCP",
+  "grep",
+  "regex",
+  "localhost",
+  "codebase",
+  "TypeScript",
+  "JavaScript",
+  "JSON",
+  "YAML",
+  "OAuth",
+  "webhook",
+  "gRPC",
+  "dotfiles",
+  "subagent",
+  "worktree",
+  "stdout",
+  "stderr",
+  "async",
+  "await",
+  "API",
+  "CLI",
+  "npm",
+  "pnpm",
+  "commit",
+  "rebase",
+  "refactor",
+  "endpoint",
+  "middleware",
+  "schema",
+  "tokenizer"
+];
+var DEFAULT_KEYTERMS_FILENAME = "voice-keyterms.txt";
+var MAX_KEYTERMS = 200;
+var MAX_KEYTERMS_BYTES = 2e3;
+var MAX_KEYTERMS_FILE_BYTES = 64 * 1024;
+function buildVoiceKeyterms(settings) {
+  const userTerms = settings ? readUserKeyterms(settings) : [];
+  return capKeyterms(dedupeKeyterms([...GLOBAL_KEYTERMS, ...userTerms]));
+}
+__name(buildVoiceKeyterms, "buildVoiceKeyterms");
+function dedupeKeyterms(terms) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const term of terms) {
+    const key = term.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    out.push(term);
+  }
+  return out;
+}
+__name(dedupeKeyterms, "dedupeKeyterms");
+function capKeyterms(terms) {
+  const out = [];
+  let bytes = 0;
+  for (const term of terms) {
+    if (out.length >= MAX_KEYTERMS) {
+      break;
+    }
+    const next = bytes + Buffer.byteLength(term, "utf8") + (out.length > 0 ? 1 : 0);
+    if (next > MAX_KEYTERMS_BYTES) {
+      continue;
+    }
+    out.push(term);
+    bytes = next;
+  }
+  return out;
+}
+__name(capKeyterms, "capKeyterms");
+function readUserKeyterms(settings) {
+  if (!settings.isTrusted) {
+    return [];
+  }
+  for (const resolved of resolveKeytermsFiles(settings)) {
+    try {
+      const file = canonicalizeKeytermsFile(resolved);
+      if (!file) {
+        continue;
+      }
+      const content = readRegularFileNoFollow(file);
+      if (content === void 0) {
+        continue;
+      }
+      const parsed = parseKeyterms(content);
+      if (parsed.length > 0) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return [];
+}
+__name(readUserKeyterms, "readUserKeyterms");
+function resolveKeytermsFiles(settings) {
+  const workspacePath = settings.workspace?.path;
+  if (!workspacePath) {
+    return [];
+  }
+  const qwenDir = path.dirname(workspacePath);
+  const workspaceRoot = path.dirname(qwenDir);
+  const configured = readKeytermsFileSettings(settings);
+  if (configured.length > 0) {
+    return configured.map(({ path: configuredPath, scope }) => {
+      const expanded = resolvePath(configuredPath);
+      const isAbsolute2 = path.isAbsolute(expanded);
+      return {
+        filePath: isAbsolute2 ? expanded : path.resolve(workspaceRoot, expanded),
+        workspaceRoot,
+        mustBeInWorkspace: scope === "system" || !isAbsolute2
+      };
+    });
+  }
+  return [
+    {
+      filePath: path.join(qwenDir, DEFAULT_KEYTERMS_FILENAME),
+      workspaceRoot,
+      mustBeInWorkspace: true
+    }
+  ];
+}
+__name(resolveKeytermsFiles, "resolveKeytermsFiles");
+function canonicalizeKeytermsFile({
+  filePath,
+  workspaceRoot,
+  mustBeInWorkspace
+}) {
+  const stat = fs.lstatSync(filePath, { throwIfNoEntry: false });
+  if (!stat || stat.isSymbolicLink() || !stat.isFile() || stat.nlink > 1 || stat.size > MAX_KEYTERMS_FILE_BYTES) {
+    return void 0;
+  }
+  const realFilePath = fs.realpathSync(filePath);
+  if (mustBeInWorkspace) {
+    const realWorkspaceRoot = fs.realpathSync(workspaceRoot);
+    if (!isSubpath(realWorkspaceRoot, realFilePath)) {
+      return void 0;
+    }
+  }
+  return { filePath: realFilePath, stat };
+}
+__name(canonicalizeKeytermsFile, "canonicalizeKeytermsFile");
+function readRegularFileNoFollow({
+  filePath,
+  stat: expectedStat
+}) {
+  let fd;
+  try {
+    let flags = fs.constants.O_RDONLY;
+    if (typeof fs.constants.O_NOFOLLOW === "number") {
+      flags |= fs.constants.O_NOFOLLOW;
+    }
+    if (typeof fs.constants.O_NONBLOCK === "number") {
+      flags |= fs.constants.O_NONBLOCK;
+    }
+    fd = fs.openSync(filePath, flags);
+    const stat = fs.fstatSync(fd);
+    if (stat.dev !== expectedStat.dev || stat.ino !== expectedStat.ino || stat.mode !== expectedStat.mode || stat.size !== expectedStat.size || stat.mtimeMs !== expectedStat.mtimeMs || stat.ctimeMs !== expectedStat.ctimeMs || !stat.isFile() || stat.nlink > 1 || stat.size > MAX_KEYTERMS_FILE_BYTES) {
+      return void 0;
+    }
+    const content = fs.readFileSync(fd, "utf-8");
+    if (Buffer.byteLength(content, "utf8") > MAX_KEYTERMS_FILE_BYTES) {
+      return void 0;
+    }
+    return content;
+  } finally {
+    if (fd !== void 0) {
+      fs.closeSync(fd);
+    }
+  }
+}
+__name(readRegularFileNoFollow, "readRegularFileNoFollow");
+function parseKeyterms(content) {
+  return content.split(/\r?\n/).map((line) => line.replace(/^\s*#.*$/, "").trim()).filter((line) => line.length > 0);
+}
+__name(parseKeyterms, "parseKeyterms");
+function readKeytermsFileSettings(settings) {
+  const out = [];
+  const system = readKeytermsFileSettingFromScope(settings.system?.settings);
+  if (system) {
+    out.push({ path: system, scope: "system" });
+  }
+  const user = readKeytermsFileSettingFromScope(settings.user?.settings);
+  if (user) {
+    out.push({ path: user, scope: "user" });
+  }
+  return out;
+}
+__name(readKeytermsFileSettings, "readKeytermsFileSettings");
+function readKeytermsFileSettingFromScope(settings) {
+  const value = settings?.general?.voice?.keytermsFile;
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+__name(readKeytermsFileSettingFromScope, "readKeytermsFileSettingFromScope");
+
+// packages/cli/src/services/voice-transcriber.ts
+var DEFAULT_OPENAI_API_KEY = "OPENAI_API_KEY";
+var INFERENCE_TIMEOUT_MS = 6e4;
+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");
+function trimTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+__name(trimTrailingSlashes, "trimTrailingSlashes");
+function readSettingsEnv(settings, envKey) {
+  const env = settings.merged.env;
+  const value = env?.[envKey];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+__name(readSettingsEnv, "readSettingsEnv");
+function isQwenBaseUrl(baseUrl) {
+  try {
+    const hostname = new URL(baseUrl).hostname.toLowerCase();
+    return hostname === "dashscope.aliyuncs.com" || hostname === "dashscope-intl.aliyuncs.com" || hostname === "dashscope-us.aliyuncs.com" || hostname.endsWith(".dashscope.aliyuncs.com") || hostname.endsWith(".dashscope-intl.aliyuncs.com") || hostname.endsWith(".dashscope-us.aliyuncs.com");
+  } catch {
+    return false;
+  }
+}
+__name(isQwenBaseUrl, "isQwenBaseUrl");
+function normalizeBaseUrl(baseUrl, modelName) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    throw new Error(`Voice model '${modelName}' has an invalid baseUrl.`);
+  }
+  url.username = "";
+  url.password = "";
+  return trimTrailingSlashes(url.toString());
+}
+__name(normalizeBaseUrl, "normalizeBaseUrl");
+function normalizeHostname(hostname) {
+  return hostname.toLowerCase().replace(/^\[|\]$/g, "");
+}
+__name(normalizeHostname, "normalizeHostname");
+function isLoopbackHost(hostname) {
+  const host = normalizeHostname(hostname);
+  return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}
+__name(isLoopbackHost, "isLoopbackHost");
+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)) {
+    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,
+    value >>> 16 & 255,
+    value >>> 8 & 255,
+    value & 255
+  ].join(".");
+}
+__name(readIpv4CompatibleIpv6, "readIpv4CompatibleIpv6");
+function isPrivateNetworkIp(hostname) {
+  const host = normalizeHostname(hostname);
+  if (isLoopbackHost(host)) {
+    return false;
+  }
+  const ipv4Mapped = host.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  if (ipv4Mapped) {
+    return isPrivateNetworkIp(ipv4Mapped[1]);
+  }
+  const ipv4Compatible = host.match(/^::(\d+\.\d+\.\d+\.\d+)$/);
+  if (ipv4Compatible) {
+    return isPrivateNetworkIp(ipv4Compatible[1]);
+  }
+  const normalizedIpv4Compatible = readIpv4CompatibleIpv6(host);
+  if (normalizedIpv4Compatible) {
+    return isPrivateNetworkIp(normalizedIpv4Compatible);
+  }
+  if (host.startsWith("::ffff:")) {
+    return true;
+  }
+  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;
+  }
+  return false;
+}
+__name(isPrivateNetworkIp, "isPrivateNetworkIp");
+async function defaultLookupHost(hostname) {
+  return dnsLookup(hostname, { all: true });
+}
+__name(defaultLookupHost, "defaultLookupHost");
+async function assertVoiceBaseUrlNetworkAllowed(voiceConfig, lookupHost) {
+  const hostname = normalizeHostname(new URL(voiceConfig.baseUrl).hostname);
+  if (isLoopbackHost(hostname)) {
+    return;
+  }
+  if (isIP(hostname) !== 0) {
+    if (isPrivateNetworkIp(hostname)) {
+      throw new Error(
+        `Voice model '${voiceConfig.model}' resolved to a private-network address.`
+      );
+    }
+    return;
+  }
+  let result;
+  try {
+    result = await (lookupHost ?? defaultLookupHost)(hostname);
+  } catch {
+    throw new Error(
+      `Voice model '${voiceConfig.model}': DNS lookup failed for ${hostname}. Cannot verify network safety.`
+    );
+  }
+  const records = Array.isArray(result) ? result : [result];
+  if (records.some((record) => isPrivateNetworkIp(record.address))) {
+    throw new Error(
+      `Voice model '${voiceConfig.model}' resolved to a private-network address.`
+    );
+  }
+}
+__name(assertVoiceBaseUrlNetworkAllowed, "assertVoiceBaseUrlNetworkAllowed");
+function readApiKey(settings, model, baseUrl) {
+  if (!model.envKey && !isQwenBaseUrl(baseUrl)) {
+    return void 0;
+  }
+  const envKey = model.envKey ?? DEFAULT_OPENAI_API_KEY;
+  const envValue = process.env[envKey];
+  if (envValue && envValue.trim().length > 0) {
+    return envValue.trim();
+  }
+  const settingsEnvValue = readSettingsEnv(settings, envKey);
+  if (settingsEnvValue) {
+    return settingsEnvValue;
+  }
+  if (!model.envKey && isQwenBaseUrl(baseUrl)) {
+    const authApiKey = settings.merged.security?.auth?.apiKey;
+    return typeof authApiKey === "string" && authApiKey.trim().length > 0 ? authApiKey.trim() : void 0;
+  }
+  return void 0;
+}
+__name(readApiKey, "readApiKey");
+function resolveVoiceTranscriptionConfig({
+  config,
+  settings,
+  voiceModel
+}) {
+  const matches = config.getAllConfiguredModels().filter((model2) => model2.id === voiceModel);
+  if (matches.length === 0) {
+    throw new Error(
+      `Voice model '${voiceModel}' is not configured. Run /model --voice to choose a configured model.`
+    );
+  }
+  if (matches.length > 1) {
+    throw new Error(`Voice model '${voiceModel}' is ambiguous.`);
+  }
+  const model = matches[0];
+  if (!isTranscribableVoiceModel(model)) {
+    throw new Error(formatUnsupportedVoiceModelMessage(voiceModel));
+  }
+  const baseUrl = model.baseUrl?.trim();
+  if (!baseUrl) {
+    throw new Error(`Voice model '${voiceModel}' does not define a baseUrl.`);
+  }
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl, voiceModel);
+  const parsedBaseUrl = new URL(normalizedBaseUrl);
+  const isLocalhost = isLoopbackHost(parsedBaseUrl.hostname);
+  if (parsedBaseUrl.protocol !== "https:" && !isLocalhost) {
+    throw new Error(
+      `Voice model '${voiceModel}' must use an https baseUrl. Voice audio must not be transmitted in cleartext.`
+    );
+  }
+  if (isPrivateNetworkIp(parsedBaseUrl.hostname)) {
+    throw new Error(
+      `Voice model '${voiceModel}' must not use a private-network baseUrl.`
+    );
+  }
+  const apiKey = readApiKey(settings, model, normalizedBaseUrl);
+  if (model.envKey && !apiKey) {
+    throw new Error(`Voice model '${voiceModel}' requires ${model.envKey}.`);
+  }
+  return {
+    model: voiceModel,
+    baseUrl: normalizedBaseUrl,
+    ...apiKey ? { apiKey } : {}
+  };
+}
+__name(resolveVoiceTranscriptionConfig, "resolveVoiceTranscriptionConfig");
+function isStreamingVoiceModel(model) {
+  const transport = resolveVoiceTransport(model);
+  return transport === "qwen-asr-realtime" || transport === "dashscope-task-realtime";
+}
+__name(isStreamingVoiceModel, "isStreamingVoiceModel");
+function resolveVoiceStreamConfig(args) {
+  const base = resolveVoiceTranscriptionConfig(args);
+  const transport = resolveVoiceTransport(base.model);
+  if (transport !== "qwen-asr-realtime" && transport !== "dashscope-task-realtime") {
+    throw new Error(
+      `Voice model '${base.model}' does not support streaming transcription.`
+    );
+  }
+  const language = resolveLanguageCode(readVoiceLanguage(args.settings));
+  const keytermsContext = transport === "qwen-asr-realtime" ? buildKeytermsContext(args.settings) : void 0;
+  return {
+    transport,
+    baseUrl: base.baseUrl,
+    model: base.model,
+    ...base.apiKey ? { apiKey: base.apiKey } : {},
+    ...language ? { language } : {},
+    ...keytermsContext ? { keytermsContext } : {}
+  };
+}
+__name(resolveVoiceStreamConfig, "resolveVoiceStreamConfig");
+var LANGUAGE_CODES = {
+  english: "en",
+  chinese: "zh",
+  mandarin: "zh",
+  cantonese: "yue",
+  japanese: "ja",
+  korean: "ko",
+  french: "fr",
+  german: "de",
+  spanish: "es",
+  italian: "it",
+  portuguese: "pt",
+  russian: "ru",
+  arabic: "ar"
+};
+function resolveLanguageCode(language) {
+  if (!language) {
+    return void 0;
+  }
+  const lower = language.toLowerCase();
+  if (LANGUAGE_CODES[lower]) {
+    return LANGUAGE_CODES[lower];
+  }
+  return /^[a-z]{2,3}$/.test(lower) ? lower : void 0;
+}
+__name(resolveLanguageCode, "resolveLanguageCode");
+function buildKeytermsContext(settings) {
+  try {
+    const keyterms = buildVoiceKeyterms(settings);
+    return keyterms.length > 0 ? keyterms.join(" ") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(buildKeytermsContext, "buildKeytermsContext");
+function tokenize(value) {
+  return value.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter(Boolean);
+}
+__name(tokenize, "tokenize");
+function isKeytermEcho(transcript, keytermsContext) {
+  if (!keytermsContext) {
+    return false;
+  }
+  const tokens = tokenize(transcript);
+  if (tokens.length < 4) {
+    return false;
+  }
+  const keyset = new Set(tokenize(keytermsContext));
+  const overlap = tokens.filter((t) => keyset.has(t)).length;
+  const transcriptRatio = overlap / tokens.length;
+  const keytermRatio = overlap / keyset.size;
+  const isEcho = overlap >= MIN_KEYTERM_ECHO_TOKENS && transcriptRatio >= 0.9 && (keytermRatio >= MIN_KEYTERM_SET_ECHO_RATIO || overlap >= MIN_ABSOLUTE_KEYTERM_ECHO_TOKENS);
+  if (isEcho) {
+    const branch = keytermRatio >= MIN_KEYTERM_SET_ECHO_RATIO ? "ratio" : "absolute";
+    debugLogger.debug(
+      `[voice] dropped likely keyterm echo (${branch}): overlap=${overlap} keysetSize=${keyset.size} transcriptRatio=${transcriptRatio.toFixed(2)} keytermRatio=${keytermRatio.toFixed(2)} text="${transcript}"`
+    );
+  }
+  return isEcho;
+}
+__name(isKeytermEcho, "isKeytermEcho");
+var MAX_AUDIO_BYTES = 10 * 1024 * 1024;
+var MAX_TRANSCRIPTION_ERROR_LENGTH = 200;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function sanitizeVoiceErrorMessage(raw, apiKey) {
+  let redacted = raw.replace(
+    /Authorization:\s*(?:Bearer|ApiKey|Basic|Token)?\s*\S+/gi,
+    "Authorization: [REDACTED]"
+  ).replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]").replace(/\b(?:api[-_ ]?key|token|secret)=\S+/gi, "[REDACTED]").replace(/\bsk-[A-Za-z0-9._-]{4,}\b/g, "[REDACTED]");
+  if (apiKey) {
+    redacted = redacted.replace(
+      new RegExp(escapeRegExp(apiKey), "g"),
+      "[REDACTED]"
+    );
+  }
+  return redacted.length > MAX_TRANSCRIPTION_ERROR_LENGTH ? `${redacted.slice(0, MAX_TRANSCRIPTION_ERROR_LENGTH)}...` : redacted;
+}
+__name(sanitizeVoiceErrorMessage, "sanitizeVoiceErrorMessage");
+function inputAudioFormat(mimeType) {
+  const subtype = mimeType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+  return subtype.startsWith("audio/") ? subtype.slice("audio/".length) || "wav" : "wav";
+}
+__name(inputAudioFormat, "inputAudioFormat");
+function transcriptionAbortSignal(abortSignal) {
+  const timeoutSignal = AbortSignal.timeout(INFERENCE_TIMEOUT_MS);
+  return abortSignal ? AbortSignal.any([abortSignal, timeoutSignal]) : timeoutSignal;
+}
+__name(transcriptionAbortSignal, "transcriptionAbortSignal");
+async function transcribeViaQwenAsr(audio, voiceConfig, options, fetchFn) {
+  if (audio.data.byteLength > MAX_AUDIO_BYTES) {
+    throw new Error(
+      "Recording is too long for transcription (max ~5 minutes / 10 MB). Try a shorter dictation."
+    );
+  }
+  const dataUrl = `data:${audio.mimeType};base64,${Buffer.from(audio.data).toString("base64")}`;
+  const messages = [];
+  if (options.keytermsContext) {
+    messages.push({
+      role: "system",
+      content: [{ type: "text", text: options.keytermsContext }]
+    });
+  }
+  messages.push({
+    role: "user",
+    content: [
+      {
+        type: "input_audio",
+        input_audio: {
+          data: dataUrl,
+          format: inputAudioFormat(audio.mimeType)
+        }
+      }
+    ]
+  });
+  const asrOptions = { enable_itn: true };
+  if (options.language) {
+    asrOptions["language"] = options.language;
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (voiceConfig.apiKey) {
+    headers["Authorization"] = `Bearer ${voiceConfig.apiKey}`;
+  }
+  let response;
+  try {
+    response = await fetchFn(
+      `${trimTrailingSlashes(voiceConfig.baseUrl)}/chat/completions`,
+      {
+        method: "POST",
+        headers,
+        redirect: "manual",
+        body: JSON.stringify({
+          model: voiceConfig.model,
+          messages,
+          asr_options: asrOptions
+        }),
+        signal: transcriptionAbortSignal(options.abortSignal)
+      }
+    );
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "TimeoutError") {
+      throw new Error(
+        `Voice transcription timed out after ${INFERENCE_TIMEOUT_MS / 1e3}s. Check ASR service health and retry.`
+      );
+    }
+    throw error;
+  }
+  if (response.status >= 300 && response.status < 400) {
+    throw new Error("Voice transcription request redirected.");
+  }
+  if (!response.ok) {
+    let details = "";
+    try {
+      details = sanitizeVoiceErrorMessage(
+        await response.text(),
+        voiceConfig.apiKey
+      );
+    } catch {
+      details = "";
+    }
+    if (/model_not_supported|unsupported model/i.test(details)) {
+      throw new Error(
+        "This voice model cannot be used for batch transcription. Use qwen3-asr-flash for batch or choose a realtime voice model such as qwen3-asr-flash-realtime / fun-asr-realtime / paraformer-realtime-v2."
+      );
+    }
+    const suffix = details ? `: ${details}` : "";
+    throw new Error(
+      `Voice transcription request failed (${response.status} ${response.statusText})${suffix}`
+    );
+  }
+  const json = await response.json();
+  const content = json.choices?.[0]?.message?.content;
+  if (typeof content !== "string") {
+    throw new Error("Voice transcription response did not include text.");
+  }
+  const text = content.trim();
+  if (isKeytermEcho(text, options.keytermsContext)) {
+    return "";
+  }
+  return text;
+}
+__name(transcribeViaQwenAsr, "transcribeViaQwenAsr");
+async function transcribeVoiceAudio(audio, args) {
+  const voiceConfig = resolveVoiceTranscriptionConfig(args);
+  await assertVoiceBaseUrlNetworkAllowed(voiceConfig, args.lookupHost);
+  const fetchFn = args.fetchFn ?? fetch;
+  const language = resolveLanguageCode(readVoiceLanguage(args.settings));
+  const keytermsContext = buildKeytermsContext(args.settings);
+  const transport = resolveVoiceTransport(voiceConfig.model);
+  switch (transport) {
+    case "qwen-asr-chat":
+      return transcribeViaQwenAsr(
+        audio,
+        voiceConfig,
+        { language, keytermsContext, abortSignal: args.abortSignal },
+        fetchFn
+      );
+    case "qwen-asr-realtime":
+    case "dashscope-task-realtime":
+      throw new Error(
+        `Voice model '${voiceConfig.model}' requires streaming transcription.`
+      );
+    case "unsupported":
+    default:
+      throw new Error(
+        `Voice model '${voiceConfig.model}' is not a supported transcription model.`
+      );
+  }
+}
+__name(transcribeVoiceAudio, "transcribeVoiceAudio");
+
+export {
+  assertVoiceBaseUrlNetworkAllowed,
+  resolveVoiceTranscriptionConfig,
+  isStreamingVoiceModel,
+  resolveVoiceStreamConfig,
+  isKeytermEcho,
+  sanitizeVoiceErrorMessage,
+  transcribeVoiceAudio
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-PF523XJX.js → chunk-HPGTGMP3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   registerCleanup
-} from "./chunk-GYZQA2FO.js";
+} from "./chunk-YLZJCUH6.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-OTBK43JR.js → chunk-HYCC3XM3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";