@qwen-code/qwen-code 0.23.3 → 0.23.4-dev.codemode-responses.20260914.87437db784

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-GSILBZLN.js → chunk-U7RWQBGZ.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-OX7IZ2G5.js";
+} from "./chunk-LF5AD7PY.js";
 import {
   observeHeadlessJsonToolResultWire
-} from "./chunk-3XLK2QMY.js";
+} from "./chunk-L3S2Y2FF.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7APZIRH3.js → chunk-V3CMBOQ6.js}

@@ -2,10 +2,13 @@
 "use strict";
 import {
   performStandaloneUpdate
-} from "./chunk-GOXQL4YH.js";
+} from "./chunk-HWRXJQ6B.js";
 import {
   updateEventEmitter
 } from "./chunk-YAF2MQZ6.js";
+import {
+  t
+} from "./chunk-I6YJZGHS.js";
 import {
   require_semver
 } from "./chunk-2AUM35J5.js";
@@ -13,10 +16,7 @@ import {
   getHomebrewLatestVersion,
   getInstallationInfo,
   resolveUpdateCommand
-} from "./chunk-N6VQ37ZZ.js";
-import {
-  t
-} from "./chunk-VZUCTJ2P.js";
+} from "./chunk-SFL6U7U7.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";

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
+ */

package/chunks/{chunk-TBEXLLAO.js → chunk-VRQZESKP.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-HGEUHUEV.js";
+} from "./chunk-54B2LTKP.js";
 import {
   formatMemoryUsage
 } from "./chunk-CHEIIBT3.js";

package/chunks/{chunk-FN3JNDRU.js → chunk-VVI7MK3V.js}

@@ -3,7 +3,7 @@
 import {
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock
-} from "./chunk-EUURTIV6.js";
+} from "./chunk-WBSJ6VPZ.js";
 import {
   escapeSystemReminderTags
 } from "./chunk-G6UUOCUT.js";
@@ -12,7 +12,7 @@ import {
 } from "./chunk-IZ2U57NY.js";
 import {
   ToolNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   createDebugLogger,
   getErrorMessage,
@@ -696,7 +696,7 @@ __name(resolveForkExecutionAllowedTools, "resolveForkExecutionAllowedTools");
 function registerForkDisplayImageForCache(config, advertisedToolNames) {
   if (!advertisedToolNames.includes(ToolNames.DISPLAY_IMAGE)) return;
   config.getToolRegistry().registerFactory(ToolNames.DISPLAY_IMAGE, async () => {
-    const { DisplayImageTool } = await import("./display-image-NAH3AZ63.js");
+    const { DisplayImageTool } = await import("./display-image-QTHALY6N.js");
     return new DisplayImageTool(config);
   });
 }

package/chunks/{chunk-EUURTIV6.js → chunk-WBSJ6VPZ.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-G6UUOCUT.js";
 import {
   ToolNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";
@@ -96,6 +96,13 @@ __name(prepareHookConfig, "prepareHookConfig");
 
 // packages/core/src/tools/skill-utils.ts
 var debugLogger2 = createDebugLogger("SKILL");
+function skillModelInvocationBlock(config, skillManager, skill) {
+  if (!config.isSkillEnabled(skill)) return "disabled";
+  if (skill.disableModelInvocation) return "hidden";
+  if (!skillManager.isSkillActive(skill)) return "inactive";
+  return void 0;
+}
+__name(skillModelInvocationBlock, "skillModelInvocationBlock");
 function buildSkillLlmContent(baseDir, body) {
   return `Base directory for this skill: ${baseDir}
 Important: ALWAYS resolve absolute paths from this base directory when working with skills.
@@ -134,7 +141,7 @@ async function collectAvailableSkillEntriesUncached(skillManager, config) {
   const allSkills = await skillManager.listSkills();
   const isEnabled = /* @__PURE__ */ __name((skill) => config.isSkillEnabled(skill), "isEnabled");
   const availableSkills = allSkills.filter(
-    (s) => !s.disableModelInvocation && skillManager.isSkillActive(s) && isEnabled(s)
+    (s) => skillModelInvocationBlock(config, skillManager, s) === void 0
   );
   const hiddenSkillNames = new Set(
     allSkills.filter((s) => s.disableModelInvocation).map((s) => s.name)
@@ -293,6 +300,7 @@ function clearLoadedSkillTracking(toolRegistry, logTag) {
 __name(clearLoadedSkillTracking, "clearLoadedSkillTracking");
 
 export {
+  skillModelInvocationBlock,
   buildSkillLlmContent,
   clearCollectedSkillEntriesCache,
   collectAvailableSkillEntries,

package/chunks/{chunk-NLNQNBZ2.js → chunk-WD6YQI5M.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-M5GB774H.js";
 import {
   sanitizeLogText
-} from "./chunk-7QYWGTHB.js";
+} from "./chunk-EPVEPTI3.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";

package/chunks/chunk-WFNEY5G7.js

@@ -0,0 +1,347 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getFunctionResponseParts,
+  sanitizeMimeForPlaceholder
+} from "./chunk-NUQ4GK5I.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/inlineMediaLimit.ts
+init_esbuild_shims();
+var DEFAULT_MAX_INLINE_MEDIA_BYTES = 10 * 1024 * 1024;
+function getMaxInlineMediaBytes() {
+  const raw = process.env["QWEN_CODE_MAX_INLINE_MEDIA_BYTES"];
+  if (raw === void 0 || raw.trim() === "") {
+    return DEFAULT_MAX_INLINE_MEDIA_BYTES;
+  }
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_INLINE_MEDIA_BYTES;
+}
+__name(getMaxInlineMediaBytes, "getMaxInlineMediaBytes");
+function approxBase64Bytes(base64) {
+  let start = 0;
+  if (base64.startsWith("data:")) {
+    const commaIndex = base64.indexOf(",");
+    if (commaIndex !== -1) {
+      start = commaIndex + 1;
+    }
+  }
+  const length = base64.length - start;
+  if (length === 0) {
+    return 0;
+  }
+  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  return Math.floor(length * 3 / 4) - padding;
+}
+__name(approxBase64Bytes, "approxBase64Bytes");
+function formatMb(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1);
+}
+__name(formatMb, "formatMb");
+function oversizedMediaPlaceholder(mimeType, bytes, limitBytes) {
+  const mime = sanitizeMimeForPlaceholder(mimeType);
+  return `[Media omitted: ${mime} is ~${formatMb(bytes)}MB, exceeding the ${formatMb(limitBytes)}MB inline limit. Ask the user to resize/compress it, or reference it via an @file path so it can be read from disk.]`;
+}
+__name(oversizedMediaPlaceholder, "oversizedMediaPlaceholder");
+function clampInlineMediaPart(part, limitBytes = getMaxInlineMediaBytes()) {
+  const data = part.inlineData?.data;
+  if (!data) {
+    return part;
+  }
+  const bytes = approxBase64Bytes(data);
+  if (bytes <= limitBytes) {
+    return part;
+  }
+  const mimeType = part.inlineData?.mimeType ?? "application/octet-stream";
+  return { text: oversizedMediaPlaceholder(mimeType, bytes, limitBytes) };
+}
+__name(clampInlineMediaPart, "clampInlineMediaPart");
+
+// packages/core/src/core/openaiContentGenerator/prefix-caching.ts
+init_esbuild_shims();
+var CACHE_KEY_PREFIX = "qwen-code:";
+var EXPLICIT_BREAKPOINT_COUNT = 2;
+function supportsOpenAIPrefixCaching(contentGeneratorConfig) {
+  return contentGeneratorConfig.authType === "openai" /* USE_OPENAI */ || contentGeneratorConfig.authType === "qwen-oauth" /* QWEN_OAUTH */;
+}
+__name(supportsOpenAIPrefixCaching, "supportsOpenAIPrefixCaching");
+function isOfficialOpenAIEndpoint(contentGeneratorConfig) {
+  if (contentGeneratorConfig.authType !== "openai" /* USE_OPENAI */) return false;
+  const { baseUrl } = contentGeneratorConfig;
+  if (!baseUrl) return false;
+  try {
+    return new URL(baseUrl).hostname.toLowerCase() === "api.openai.com";
+  } catch {
+    return false;
+  }
+}
+__name(isOfficialOpenAIEndpoint, "isOfficialOpenAIEndpoint");
+function supportsExplicitOpenAIPromptCaching(model) {
+  const match = /^gpt-(\d+)(?:\.(\d+))?(?:[-.]|$)/i.exec(model);
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2] ?? 0);
+  return major > 5 || major === 5 && minor >= 6;
+}
+__name(supportsExplicitOpenAIPromptCaching, "supportsExplicitOpenAIPromptCaching");
+function withCacheBreakpoint(message) {
+  if (message.role !== "user" && message.role !== "tool") return void 0;
+  const marker = { prompt_cache_breakpoint: { mode: "explicit" } };
+  if (typeof message.content === "string") {
+    return {
+      ...message,
+      content: [{ type: "text", text: message.content, ...marker }]
+    };
+  }
+  if (!Array.isArray(message.content) || message.content.length === 0) {
+    return void 0;
+  }
+  const content = [...message.content];
+  const lastIndex = content.length - 1;
+  content[lastIndex] = { ...content[lastIndex], ...marker };
+  return { ...message, content };
+}
+__name(withCacheBreakpoint, "withCacheBreakpoint");
+function applyOfficialOpenAIPromptCaching(request, sessionId, cacheSharing, cacheKeyPartition) {
+  const result = { ...request };
+  if (sessionId && !result.prompt_cache_key) {
+    const partition = cacheKeyPartition ? `:${cacheKeyPartition}` : "";
+    result.prompt_cache_key = `${CACHE_KEY_PREFIX}${sessionId}${partition}`;
+  }
+  if (!cacheSharing || !supportsExplicitOpenAIPromptCaching(request.model)) {
+    return result;
+  }
+  const messages = [...request.messages];
+  let marked = 0;
+  for (let index = messages.length - 2; index >= 0 && marked < EXPLICIT_BREAKPOINT_COUNT; index -= 1) {
+    const message = messages[index];
+    const updated = message ? withCacheBreakpoint(message) : void 0;
+    if (!updated) continue;
+    messages[index] = updated;
+    marked += 1;
+  }
+  if (marked === 0) return result;
+  result.messages = messages;
+  result.prompt_cache_options = {
+    ...result.prompt_cache_options,
+    mode: "explicit"
+  };
+  return result;
+}
+__name(applyOfficialOpenAIPromptCaching, "applyOfficialOpenAIPromptCaching");
+
+// packages/core/src/services/image-payload-references.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+var IMAGE_ID_LENGTH = 12;
+var IMAGE_REFERENCE_PATTERN = new RegExp(
+  `\\[Image #([a-f0-9]{${IMAGE_ID_LENGTH}}): [^\\]]+\\]`,
+  "gi"
+);
+var InMemoryImagePayloadStore = class {
+  static {
+    __name(this, "InMemoryImagePayloadStore");
+  }
+  images = /* @__PURE__ */ new Map();
+  put(part) {
+    const stored = imagePartToStoredPayload(part);
+    this.images.set(stored.id, stored);
+    return stored;
+  }
+  get(id) {
+    return this.images.get(id);
+  }
+};
+function countAllInlineImages(contents) {
+  let count = 0;
+  for (const _part of inlineImageParts(contents)) count++;
+  return count;
+}
+__name(countAllInlineImages, "countAllInlineImages");
+function replaceImagePayloadsInPlace(contents, store, skipContent) {
+  const replaced = [];
+  for (const part of inlineImageParts(contents, skipContent)) {
+    const stored = store.put(part);
+    replaced.push(stored);
+    part.text = imageReferenceText(stored);
+    delete part.inlineData;
+  }
+  return replaced;
+}
+__name(replaceImagePayloadsInPlace, "replaceImagePayloadsInPlace");
+function buildReattachParts(replaced, maxRecentImages, referencedContents = [], store) {
+  const referencedIds = collectReferencedImageIds(referencedContents);
+  if (replaced.length === 0 && (!store || referencedIds.size === 0)) return [];
+  const inlineIds = collectInlineImageIds(referencedContents);
+  const last = referencedContents.at(-1);
+  const lastReferencedIds = collectReferencedImageIds(
+    last?.role === "user" ? [last] : []
+  );
+  const candidates = replaced.filter(
+    (image) => !inlineIds.has(image.id) && !lastReferencedIds.has(image.id)
+  ).map((stored) => ({ stored }));
+  if (store) {
+    for (const id of referencedIds) {
+      if (inlineIds.has(id) || lastReferencedIds.has(id)) continue;
+      const stored = store.get(id);
+      if (stored) candidates.push({ stored });
+    }
+  }
+  const recent = recentUniqueImages(candidates, maxRecentImages).map(
+    ({ stored }) => stored
+  );
+  const reattachLimit = Math.max(maxRecentImages, 1);
+  if (store) {
+    for (const id of lastReferencedIds) {
+      if (inlineIds.has(id) || recent.some((image) => image.id === id)) {
+        continue;
+      }
+      const stored = store.get(id);
+      if (stored) {
+        if (recent.length >= reattachLimit) recent.shift();
+        recent.push(stored);
+      }
+    }
+  }
+  if (recent.length === 0) return [];
+  return [
+    {
+      text: reattachContextText(recent.map((img) => img.id)),
+      partMetadata: { [REATTACH_BOUNDARY_METADATA]: true }
+    },
+    ...recent.map(storedImageToPart)
+  ];
+}
+__name(buildReattachParts, "buildReattachParts");
+var REATTACH_BOUNDARY_METADATA = "qwen-code:reattach-boundary";
+function trailingReattachPartCount(contents) {
+  const last = Array.isArray(contents) ? contents.at(-1) : void 0;
+  const parts = last && typeof last === "object" && "parts" in last ? last.parts : void 0;
+  if (!Array.isArray(parts) || parts.length === 0) return 0;
+  const firstMarked = parts.findIndex(
+    (part) => typeof part === "object" && part !== null && part.partMetadata?.[REATTACH_BOUNDARY_METADATA] === true
+  );
+  if (firstMarked === -1) return 0;
+  return parts.length - firstMarked;
+}
+__name(trailingReattachPartCount, "trailingReattachPartCount");
+function collectInlineImageIds(contents) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const part of inlineImageParts(contents)) {
+    ids.add(imagePartToStoredPayload(part).id);
+  }
+  return ids;
+}
+__name(collectInlineImageIds, "collectInlineImageIds");
+function* inlineImageParts(contents, skipContent) {
+  for (const content of contents) {
+    if (content === skipContent) continue;
+    for (const part of content.parts ?? []) {
+      if (part.inlineData?.mimeType?.startsWith("image/") && part.inlineData.data) {
+        yield part;
+      }
+      for (const inner of getFunctionResponseParts(part) ?? []) {
+        if (inner.inlineData?.mimeType?.startsWith("image/") && inner.inlineData.data) {
+          yield inner;
+        }
+      }
+    }
+  }
+}
+__name(inlineImageParts, "inlineImageParts");
+function collectReferencedImageIds(contents) {
+  const ids = /* @__PURE__ */ new Set();
+  const collect = /* @__PURE__ */ __name((parts) => {
+    for (const part of parts ?? []) {
+      for (const match of part.text?.matchAll(IMAGE_REFERENCE_PATTERN) ?? []) {
+        const id = match[1];
+        if (id) ids.add(id.toLowerCase());
+      }
+      collect(getFunctionResponseParts(part));
+    }
+  }, "collect");
+  for (const content of contents) {
+    collect(content.parts);
+  }
+  return ids;
+}
+__name(collectReferencedImageIds, "collectReferencedImageIds");
+function recentUniqueImages(collected, maxRecentImages) {
+  if (maxRecentImages <= 0) {
+    return [];
+  }
+  const recent = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = collected.length - 1; index >= 0; index--) {
+    const image = collected[index];
+    if (!image || seen.has(image.stored.id)) continue;
+    seen.add(image.stored.id);
+    recent.push(image);
+    if (recent.length === maxRecentImages) break;
+  }
+  return recent.reverse();
+}
+__name(recentUniqueImages, "recentUniqueImages");
+function imagePartToStoredPayload(part) {
+  const data = part.inlineData?.data ?? "";
+  const mimeType = part.inlineData?.mimeType ?? "application/octet-stream";
+  const hash = createHash("sha256").update(mimeType).update("\0").update(data).digest("hex");
+  return {
+    id: hash.slice(0, IMAGE_ID_LENGTH),
+    mimeType,
+    data,
+    bytes: approxBase64Bytes(data),
+    displayName: part.inlineData?.displayName
+  };
+}
+__name(imagePartToStoredPayload, "imagePartToStoredPayload");
+function imageReferenceText(stored) {
+  return `[Image #${stored.id}: ${safeImageMimeType(stored.mimeType)}, ${stored.bytes} bytes]`;
+}
+__name(imageReferenceText, "imageReferenceText");
+function reattachContextText(ids) {
+  return "Images read earlier in this session (may be OUTDATED, do not treat as current UI state): " + ids.map((id) => `Image #${id}`).join(", ");
+}
+__name(reattachContextText, "reattachContextText");
+function safeImageMimeType(mimeType) {
+  return /^image\/[a-z0-9.+-]{1,64}$/i.test(mimeType) ? mimeType.toLowerCase() : "image/unknown";
+}
+__name(safeImageMimeType, "safeImageMimeType");
+function storedImageToPart(stored) {
+  return {
+    inlineData: {
+      mimeType: stored.mimeType,
+      data: stored.data,
+      displayName: stored.displayName
+    }
+  };
+}
+__name(storedImageToPart, "storedImageToPart");
+
+export {
+  supportsOpenAIPrefixCaching,
+  isOfficialOpenAIEndpoint,
+  applyOfficialOpenAIPromptCaching,
+  approxBase64Bytes,
+  clampInlineMediaPart,
+  InMemoryImagePayloadStore,
+  countAllInlineImages,
+  replaceImagePayloadsInPlace,
+  buildReattachParts,
+  trailingReattachPartCount
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */