@qwen-code/qwen-code 0.20.2-headless-image-routing.1 → 0.21.0

package/chunks/{chunk-LESHKUWF.js → chunk-DLWL3Z7A.js}

@@ -7,15 +7,17 @@ import {
   resolveRequestTimeout
 } from "./chunk-GLNBDYUX.js";
 import {
-  buildRuntimeFetchOptions,
   defaultOutputCeiling,
   hasExplicitOutputLimit,
   parsePositiveIntegerEnvValue,
   tokenLimit
-} from "./chunk-CBOQ3HY7.js";
+} from "./chunk-UW5EOVUN.js";
+import {
+  buildRuntimeFetchOptions
+} from "./chunk-2JZBVYTU.js";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-XHATNRQA.js → chunk-DP3IHZGG.js}

@@ -1494,7 +1494,5 @@ var require_semver2 = __commonJS({
 });
 
 export {
-  require_diff,
-  require_gt,
   require_semver2 as require_semver
 };

package/chunks/chunk-E5TUC6CA.js

@@ -0,0 +1,479 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isPrivateHost
+} from "./chunk-NH6KE4JX.js";
+import {
+  loadUndici
+} from "./chunk-2JZBVYTU.js";
+import {
+  getErrorMessage
+} from "./chunk-NL7LTRLR.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/services/image-generation-service.ts
+init_esbuild_shims();
+
+// packages/core/src/extension/network-policy.ts
+init_esbuild_shims();
+import { promises as dns } from "node:dns";
+import { BlockList, isIP } from "node:net";
+var blockedAddresses = new BlockList();
+var publicIpv6Addresses = new BlockList();
+publicIpv6Addresses.addSubnet("2000::", 3, "ipv6");
+for (const [address, prefix] of [
+  ["0.0.0.0", 8],
+  ["10.0.0.0", 8],
+  ["100.64.0.0", 10],
+  ["127.0.0.0", 8],
+  ["169.254.0.0", 16],
+  ["172.16.0.0", 12],
+  ["192.0.0.0", 24],
+  ["192.0.2.0", 24],
+  ["192.88.99.0", 24],
+  ["192.168.0.0", 16],
+  ["198.18.0.0", 15],
+  ["198.51.100.0", 24],
+  ["203.0.113.0", 24],
+  ["224.0.0.0", 4],
+  ["240.0.0.0", 4]
+]) {
+  blockedAddresses.addSubnet(address, prefix, "ipv4");
+}
+for (const [address, prefix] of [
+  ["2001::", 23],
+  ["2001:db8::", 32],
+  ["2002::", 16],
+  ["3fff::", 20]
+]) {
+  blockedAddresses.addSubnet(address, prefix, "ipv6");
+}
+async function waitForAbortable(promise, signal) {
+  if (!signal) return await promise;
+  signal.throwIfAborted();
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = /* @__PURE__ */ __name((callback) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      callback();
+    }, "finish");
+    const onAbort = /* @__PURE__ */ __name(() => finish(() => reject(signal.reason)), "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    promise.then(
+      (value) => finish(() => resolve(value)),
+      (error) => finish(() => reject(error))
+    );
+  });
+}
+__name(waitForAbortable, "waitForAbortable");
+function stripIpv6Brackets(hostname) {
+  return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+}
+__name(stripIpv6Brackets, "stripIpv6Brackets");
+function parseMappedIpv4(address) {
+  const suffix = address.toLowerCase().slice("::ffff:".length);
+  if (isIP(suffix) === 4) return suffix;
+  const parts = suffix.split(":");
+  if (parts.length !== 2 || parts.some((part) => !/^[\da-f]{1,4}$/.test(part))) {
+    return void 0;
+  }
+  const upper = Number.parseInt(parts[0], 16);
+  const lower = Number.parseInt(parts[1], 16);
+  return `${upper >> 8}.${upper & 255}.${lower >> 8}.${lower & 255}`;
+}
+__name(parseMappedIpv4, "parseMappedIpv4");
+function isBlockedAddress(address, family) {
+  if (family === 6 && address.toLowerCase().startsWith("::ffff:")) {
+    const mapped = parseMappedIpv4(address);
+    return mapped === void 0 || isBlockedAddress(mapped, 4);
+  }
+  if (family === 6 && !publicIpv6Addresses.check(address, "ipv6")) return true;
+  return blockedAddresses.check(address, family === 6 ? "ipv6" : "ipv4");
+}
+__name(isBlockedAddress, "isBlockedAddress");
+async function resolveNetworkTarget(value, policy, signal) {
+  signal?.throwIfAborted();
+  const url = value instanceof URL ? value : new URL(value);
+  if (policy !== "public") return { url };
+  if (url.protocol !== "https:") {
+    throw new Error("Public extension network requests must use HTTPS.");
+  }
+  if (url.username || url.password) {
+    throw new Error(
+      "Public extension network requests must not use credentials."
+    );
+  }
+  const hostname = stripIpv6Brackets(url.hostname);
+  const literalFamily = isIP(hostname);
+  const addresses = literalFamily ? [{ address: hostname, family: literalFamily }] : await waitForAbortable(
+    dns.lookup(hostname, { all: true, verbatim: true }),
+    signal
+  );
+  if (addresses.length === 0) {
+    throw new Error(`Extension network host did not resolve: ${hostname}`);
+  }
+  if (addresses.some(({ address, family }) => isBlockedAddress(address, family))) {
+    throw new Error(
+      `Extension network host resolved to a blocked address: ${hostname}`
+    );
+  }
+  const selected = addresses[0];
+  const lookup = /* @__PURE__ */ __name((requestedHostname, options, callback) => {
+    if (stripIpv6Brackets(requestedHostname) !== hostname) {
+      const error = new Error(
+        "Pinned extension lookup hostname mismatch"
+      );
+      error.code = "ENOTFOUND";
+      callback(error, "", 0);
+      return;
+    }
+    if (options.all) {
+      callback(null, [selected]);
+    } else {
+      callback(null, selected.address, selected.family);
+    }
+  }, "lookup");
+  const port = url.port || "443";
+  const curlHostname = literalFamily === 6 ? `[${hostname}]` : hostname;
+  const curlAddress = selected.family === 6 ? `[${selected.address}]` : selected.address;
+  return {
+    url,
+    lookup,
+    curlResolve: `${curlHostname}:${port}:${curlAddress}`
+  };
+}
+__name(resolveNetworkTarget, "resolveNetworkTarget");
+
+// packages/core/src/services/image-generation-service.ts
+var GENERATION_TIMEOUT_MS = 24e4;
+var DOWNLOAD_TIMEOUT_MS = 12e4;
+var MAX_API_RESPONSE_BYTES = 1024 * 1024;
+var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var MAX_DOWNLOAD_REDIRECTS = 3;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var PNG_SIGNATURE = Buffer.from([
+  137,
+  80,
+  78,
+  71,
+  13,
+  10,
+  26,
+  10
+]);
+var ResponseSizeLimitError = class extends Error {
+  static {
+    __name(this, "ResponseSizeLimitError");
+  }
+};
+function normalizeImageGenerationBaseUrl(value) {
+  const baseUrl = value?.trim();
+  if (!baseUrl) return void 0;
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    return void 0;
+  }
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.search || parsed.hash) {
+    return void 0;
+  }
+  return parsed.toString().replace(/\/+$/, "");
+}
+__name(normalizeImageGenerationBaseUrl, "normalizeImageGenerationBaseUrl");
+async function generateImage(request) {
+  const fetchFn = request.fetchFn ?? fetch;
+  const baseUrl = normalizeImageGenerationBaseUrl(request.baseUrl);
+  if (!baseUrl) {
+    throw new Error(
+      "Image generation baseUrl must be a valid HTTPS URL without credentials, query, or fragment."
+    );
+  }
+  const generationUrl = baseUrl.endsWith(
+    "/services/aigc/multimodal-generation/generation"
+  ) ? baseUrl : `${baseUrl}/services/aigc/multimodal-generation/generation`;
+  const parameters = {
+    n: 1,
+    prompt_extend: true,
+    watermark: false
+  };
+  if (request.size) {
+    parameters["size"] = request.size;
+  }
+  let response;
+  try {
+    response = await fetchFn(generationUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${request.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: request.model,
+        input: {
+          messages: [
+            {
+              role: "user",
+              content: [{ text: request.prompt }]
+            }
+          ]
+        },
+        parameters
+      }),
+      redirect: "error",
+      signal: combineWithTimeout(request.signal, GENERATION_TIMEOUT_MS)
+    });
+  } catch (error) {
+    throw new Error(
+      `Image generation request failed: ${getErrorMessage(error)}`,
+      { cause: error }
+    );
+  }
+  if (!response.ok) {
+    let payload2 = {};
+    try {
+      payload2 = await readJsonResponse(response, MAX_API_RESPONSE_BYTES);
+    } catch {
+    }
+    throw new Error(formatImageGenerationError(response.status, payload2));
+  }
+  const payload = await readJsonResponse(response, MAX_API_RESPONSE_BYTES);
+  const imageUrl = findGeneratedImageUrl(payload);
+  if (!imageUrl) {
+    throw new Error("Image generation response did not contain an image URL.");
+  }
+  const bytes = await downloadPng(imageUrl, fetchFn, request.signal);
+  const requestId = readString(payload, "request_id", "requestId");
+  return {
+    bytes,
+    mimeType: "image/png",
+    ...requestId ? { requestId } : {}
+  };
+}
+__name(generateImage, "generateImage");
+async function readJsonResponse(response, maxBytes) {
+  const bytes = await readBoundedBody(response, maxBytes);
+  if (bytes.length === 0) {
+    return {};
+  }
+  try {
+    return JSON.parse(bytes.toString("utf8"));
+  } catch {
+    throw new Error(
+      `Image generation endpoint returned malformed JSON (HTTP ${response.status}).`
+    );
+  }
+}
+__name(readJsonResponse, "readJsonResponse");
+async function readBoundedBody(response, maxBytes) {
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    await response.body?.cancel().catch(() => {
+    });
+    throw new ResponseSizeLimitError(
+      `Response exceeds the ${maxBytes}-byte limit.`
+    );
+  }
+  if (!response.body) {
+    return Buffer.alloc(0);
+  }
+  const chunks = [];
+  let total = 0;
+  const reader = response.body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        throw new ResponseSizeLimitError(
+          `Response exceeds the ${maxBytes}-byte limit.`
+        );
+      }
+      chunks.push(value);
+    }
+  } finally {
+    await reader.cancel().catch(() => {
+    });
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, total);
+}
+__name(readBoundedBody, "readBoundedBody");
+function formatImageGenerationError(status, payload) {
+  const code = readString(payload, "code");
+  const message = readString(payload, "message");
+  const suffix = [code, message].filter(Boolean).join(": ");
+  if (status === 429 || /throttl|rate.?limit/i.test(`${code} ${message}`)) {
+    return `Image generation rate limit reached${suffix ? ` (${suffix})` : ""}.`;
+  }
+  if (status === 401 || status === 403 || /access|permission/i.test(code ?? "")) {
+    return `Image generation access denied${suffix ? ` (${suffix})` : ""}. Check the API key, endpoint, and model access.`;
+  }
+  if (/DataInspectionFailed/i.test(code ?? "")) {
+    return `The image generation endpoint blocked the prompt during content moderation${message ? `: ${message}` : "."}`;
+  }
+  return `Image generation failed with HTTP ${status}${suffix ? ` (${suffix})` : ""}.`;
+}
+__name(formatImageGenerationError, "formatImageGenerationError");
+function findGeneratedImageUrl(payload) {
+  if (!isRecord(payload)) return void 0;
+  const output = payload["output"];
+  if (!isRecord(output) || !Array.isArray(output["choices"])) return void 0;
+  for (const choice of output["choices"]) {
+    if (!isRecord(choice)) continue;
+    const message = choice["message"];
+    if (!isRecord(message) || !Array.isArray(message["content"])) continue;
+    for (const part of message["content"]) {
+      if (!isRecord(part)) continue;
+      const image = part["image"];
+      if (typeof image === "string" && image.trim()) {
+        return image.trim();
+      }
+    }
+  }
+  return void 0;
+}
+__name(findGeneratedImageUrl, "findGeneratedImageUrl");
+async function downloadPng(imageUrl, fetchFn, signal) {
+  const combinedSignal = combineWithTimeout(signal, DOWNLOAD_TIMEOUT_MS);
+  let currentTarget = await validateResultUrl(imageUrl, combinedSignal);
+  for (let redirectCount = 0; redirectCount <= MAX_DOWNLOAD_REDIRECTS; redirectCount++) {
+    let dispatcher;
+    if (currentTarget.lookup) {
+      const undici = await loadUndici();
+      const { Agent } = undici;
+      dispatcher = new Agent({ connect: { lookup: currentTarget.lookup } });
+    }
+    let response;
+    try {
+      response = await fetchFn(currentTarget.url.toString(), {
+        method: "GET",
+        headers: { Accept: "image/png" },
+        redirect: "manual",
+        signal: combinedSignal,
+        ...dispatcher ? { dispatcher } : {}
+      });
+    } catch (error) {
+      await dispatcher?.close();
+      throw new Error("Generated image download failed before completion.", {
+        cause: error
+      });
+    }
+    try {
+      if (REDIRECT_STATUSES.has(response.status)) {
+        const location = response.headers.get("location");
+        await response.body?.cancel().catch(() => {
+        });
+        if (!location) {
+          throw new Error(
+            "Generated image redirect is missing a Location header."
+          );
+        }
+        let redirectUrl;
+        try {
+          redirectUrl = new URL(
+            location,
+            currentTarget.url.toString()
+          ).toString();
+        } catch {
+          throw new Error("Generated image redirect URL is invalid.");
+        }
+        currentTarget = await validateResultUrl(redirectUrl, combinedSignal);
+        continue;
+      }
+      if (!response.ok) {
+        await response.body?.cancel().catch(() => {
+        });
+        throw new Error(
+          `Generated image download failed with HTTP ${response.status}.`
+        );
+      }
+      let bytes;
+      try {
+        bytes = await readBoundedBody(response, MAX_IMAGE_BYTES);
+      } catch (error) {
+        if (error instanceof ResponseSizeLimitError) {
+          throw error;
+        }
+        throw new Error("Generated image download failed before completion.", {
+          cause: error
+        });
+      }
+      if (bytes.length < PNG_SIGNATURE.length || !bytes.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) {
+        throw new Error("Downloaded result is not a valid PNG image.");
+      }
+      return bytes;
+    } finally {
+      await dispatcher?.close();
+    }
+  }
+  throw new Error(
+    `Generated image download exceeded ${MAX_DOWNLOAD_REDIRECTS} redirects.`
+  );
+}
+__name(downloadPng, "downloadPng");
+async function validateResultUrl(value, signal) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new Error("Image generation returned an invalid image URL.");
+  }
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password || isPrivateHost(parsed.toString())) {
+    throw new Error(
+      "Image generation returned an image URL that is not a safe public HTTPS URL."
+    );
+  }
+  try {
+    return await resolveNetworkTarget(parsed, "public", signal);
+  } catch (error) {
+    signal.throwIfAborted();
+    throw new Error(
+      "Image generation returned an image URL that is not a safe public HTTPS URL.",
+      { cause: error }
+    );
+  }
+}
+__name(validateResultUrl, "validateResultUrl");
+function combineWithTimeout(signal, timeoutMs) {
+  return AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]);
+}
+__name(combineWithTimeout, "combineWithTimeout");
+function readString(value, ...keys) {
+  if (!isRecord(value)) return void 0;
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return void 0;
+}
+__name(readString, "readString");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+
+export {
+  resolveNetworkTarget,
+  normalizeImageGenerationBaseUrl,
+  generateImage
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-JC26SJ5Y.js → chunk-EBJQ6AXW.js}

@@ -1,11 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  formatHistoryGapNotice
-} from "./chunk-LNDD3IML.js";
 import {
   sanitizeTerminalText
-} from "./chunk-RS7MT2QG.js";
+} from "./chunk-IPUUTYMV.js";
+import {
+  formatHistoryGapNotice
+} from "./chunk-WCXCRJYB.js";
 import {
   isGoalStatusKind,
   isTerminalGoalStatusKind
@@ -23,18 +23,18 @@ import {
   setGoalTerminalObserver,
   setLastGoalTerminal,
   unregisterGoalHook
-} from "./chunk-OTQ6PSZC.js";
+} from "./chunk-PHOF65IG.js";
 import {
   apiActivityTracker,
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-ZDP2Y2AL.js";
+} from "./chunk-CIKQ7KKO.js";
 import {
   ToolNames
-} from "./chunk-YM3SZTH4.js";
+} from "./chunk-PR75REBZ.js";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -677,9 +677,6 @@ async function realpathOrResolve(input) {
 }
 __name(realpathOrResolve, "realpathOrResolve");
 
-// packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
-init_esbuild_shims();
-
 // packages/acp-bridge/src/transcript-replay.ts
 init_esbuild_shims();
 var MISSING_TRANSCRIPT_TOOL_RESULT_MESSAGE = "Tool result missing from saved history; the previous run likely ended before this tool completed.";
@@ -1535,6 +1532,9 @@ function dedupeStrings(values) {
 }
 __name(dedupeStrings, "dedupeStrings");
 
+// packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
+init_esbuild_shims();
+
 // packages/cli/src/acp-integration/session/emitters/base-emitter.ts
 init_esbuild_shims();
 var BaseEmitter = class {
@@ -2496,7 +2496,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./src-IZXLJI5M.js");
+    const { getGitRepoName } = await import("./src-GE4TTTML.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;
@@ -3351,6 +3351,7 @@ export {
   GITHUB_WORKFLOW_PATHS,
   SetupGithubError,
   setupGithub,
+  createTranscriptMessageUpdate,
   MessageEmitter,
   PlanEmitter,
   ToolCallEmitter,