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

package/chunks/{chunk-CXTPVBFA.js → chunk-GSS4SZNG.js}

@@ -8,18 +8,18 @@ import {
 } from "./chunk-JL6APGBX.js";
 import {
   buildSessionAwareFetch
-} from "./chunk-NOO4QFXM.js";
+} from "./chunk-C75BXMPM.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
-} from "./chunk-ZHKTKHMO.js";
+} from "./chunk-7MIBD3LG.js";
 import {
   REASONING_EFFORT_TIERS,
   clampReasoningEffort,
   getGptReasoningCapabilities,
   isReasoningEffortPlaceholder,
   parseModelReasoningCapabilities
-} from "./chunk-3FPYT6QC.js";
+} from "./chunk-ARDHE6MM.js";
 import {
   defaultOutputCeiling,
   hasExplicitOutputLimit,
@@ -480,16 +480,20 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
    *
    * This method applies DashScope-specific configurations including:
    * - Cache control for the system message, last tool message (when tools are configured),
-   *   and the latest history message
+   *   and the latest history message — or, when a reattach region trails the
+   *   conversation, the last stable block before it
    * - Output token limits based on model capabilities
    * - Vision model specific parameters (vl_high_resolution_images)
    * - Request metadata for session tracking
    *
    * @param request - The original chat completion request parameters
    * @param userPromptId - Unique identifier for the user prompt for session tracking
+   * @param reattachBlockCount - Number of trailing blocks in the last message that
+   *   belong to the regenerated reattach region; the conversation cache breakpoint
+   *   is placed before them. Defaults to 0 (last block of the last message).
    * @returns Configured request with DashScope-specific parameters applied
    */
-  buildRequest(request, userPromptId) {
+  buildRequest(request, userPromptId, reattachBlockCount = 0) {
     let messages = request.messages;
     let tools = request.tools;
     const flattenPlainTextForGlm = this.isGlmModel(request.model) && !this.hasFunctionCallingContext(request);
@@ -498,7 +502,8 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     } else if (this.shouldEnableCacheControl()) {
       const { messages: updatedMessages, tools: updatedTools } = this.addDashScopeCacheControl(
         request,
-        request.stream ? "all" : "system_only"
+        request.stream ? "all" : "system_only",
+        reattachBlockCount
       );
       messages = updatedMessages;
       tools = updatedTools;
@@ -530,7 +535,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
         ...requestParams,
         messages,
         ...tools ? { tools } : {},
-        ...this.buildMetadata(userPromptId) || {},
+        ...this.buildRequestMetadata(request.model, userPromptId),
         ...dashscopeExtras2
       };
       if (hasQwenEffortConfig && "reasoning" in visionResult) {
@@ -552,7 +557,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       // Preserve all original parameters including sampling params and adjusted max_tokens
       messages,
       ...tools ? { tools } : {},
-      ...this.buildMetadata(userPromptId) || {},
+      ...this.buildRequestMetadata(request.model, userPromptId),
       ...dashscopeExtras
     };
     if (hasQwenEffortConfig && "reasoning" in result) {
@@ -737,6 +742,49 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     }
   }
   conflictingKnobDropWarned = false;
+  /**
+   * DashScope is an aggregating gateway: a non-qwen model (e.g. `ZHIPU/GLM-...`)
+   * reached through the same endpoint has its request forwarded to that vendor's
+   * own backend, `metadata` object included. Those backends type `metadata` as a
+   * string, so the object fails to deserialize and the request is rejected with a
+   * flat 400, making the model unusable through Qwen Code. `metadata` is a
+   * platform-private tracing field (sessionId / promptId / channel) that only
+   * means anything to DashScope's own inference path, so gate it on the wire model
+   * the same way `buildQwenEffortConfig` gates the qwen-only thinking knobs, for
+   * the same stated reason: qwen-specific fields must not leak to a non-qwen model
+   * sharing the endpoint.
+   *
+   * This is orthogonal to which *origins* count as DashScope-compatible, so the
+   * `*.alicloudapi.com` recognition added in #9103 is untouched: a qwen model
+   * behind such a gateway still ships metadata.
+   */
+  buildRequestMetadata(model, userPromptId) {
+    if (!this.shouldSendRequestMetadata(model)) {
+      return {};
+    }
+    return this.buildMetadata(userPromptId) || {};
+  }
+  /**
+   * Auto by default: qwen-family wire models only, per the gateway reasoning on
+   * {@link buildRequestMetadata}. The client cannot tell a forwarded request from
+   * one DashScope serves itself, so an explicit `enableRequestMetadata` wins in
+   * both directions: `true` restores the field for a non-qwen model served
+   * first-party whose tracing still matters, `false` suppresses it everywhere.
+   * Read only from the provider's own config, never the session's. A
+   * side-model generator is built with its own per-model config but shares
+   * the session `Config`, and a cross-provider agent config deliberately
+   * clears this field, so any session fallback would let the main model's
+   * value decide a different model's request. On the main route the provider
+   * config is the same object the qwen-oauth hot switch mutates in place, so
+   * nothing is latched here.
+   */
+  shouldSendRequestMetadata(model) {
+    const configured = this.contentGeneratorConfig.enableRequestMetadata;
+    if (typeof configured === "boolean") {
+      return configured;
+    }
+    return isQwenFamilyWireModel(this.resolveWireModel(model));
+  }
   buildMetadata(userPromptId) {
     const channel = this.cliConfig.getChannel?.();
     return {
@@ -753,20 +801,25 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
   /**
    * Add cache control flag to specified message(s) for DashScope providers
    */
-  addDashScopeCacheControl(request, cacheControl) {
+  addDashScopeCacheControl(request, cacheControl, reattachBlockCount = 0) {
     const messages = request.messages;
     const systemIndex = messages.findIndex((msg) => msg.role === "system");
     const lastIndex = messages.length - 1;
+    const stableBlock = reattachBlockCount > 0 && lastIndex >= 0 ? this.lastStableBlock(messages, reattachBlockCount) : { messageIndex: lastIndex, excludeTail: 0 };
     const updatedMessages = messages.length === 0 ? messages : messages.map((message, index) => {
+      const isConversationAnchor = stableBlock?.messageIndex === index && cacheControl === "all";
       const shouldAddCacheControl = Boolean(
-        index === systemIndex && systemIndex !== -1 || index === lastIndex && cacheControl === "all"
+        index === systemIndex && systemIndex !== -1 || isConversationAnchor
       );
       if (!shouldAddCacheControl || !("content" in message) || message.content === null || message.content === void 0) {
         return message;
       }
       return {
         ...message,
-        content: this.addCacheControlToContent(message.content)
+        content: this.addCacheControlToContent(
+          message.content,
+          isConversationAnchor && stableBlock ? stableBlock.excludeTail : 0
+        )
       };
     });
     const updatedTools = cacheControl === "all" && request.tools?.length ? this.addCacheControlToTools(request.tools) : request.tools;
@@ -775,6 +828,25 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       tools: updatedTools
     };
   }
+  /**
+   * Locate the last block that is not part of the trailing reattach region,
+   * walking back through messages as needed. Returns the owning message index
+   * plus how many trailing blocks of that message to skip when stamping the
+   * conversation `cache_control` breakpoint.
+   */
+  lastStableBlock(messages, reattachBlockCount) {
+    let remaining = reattachBlockCount;
+    for (let index = messages.length - 1; index >= 0; index--) {
+      const content = messages[index].content;
+      const blockCount = typeof content === "string" ? content.length > 0 ? 1 : 0 : Array.isArray(content) ? content.length : 0;
+      if (blockCount === 0) continue;
+      if (blockCount > remaining) {
+        return { messageIndex: index, excludeTail: remaining };
+      }
+      remaining -= blockCount;
+    }
+    return void 0;
+  }
   addCacheControlToTools(tools) {
     if (tools.length === 0) {
       return tools;
@@ -790,9 +862,9 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
   /**
    * Add cache control to message content, handling both string and array formats
    */
-  addCacheControlToContent(content) {
+  addCacheControlToContent(content, excludeTail = 0) {
     const contentArray = this.normalizeContentToArray(content);
-    return this.addCacheControlToContentArray(contentArray);
+    return this.addCacheControlToContentArray(contentArray, excludeTail);
   }
   /**
    * Normalize content to array format
@@ -809,14 +881,25 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     return [...content];
   }
   /**
-   * Add cache control to the content array
+   * Add cache control to the content array, skipping `excludeTail` trailing
+   * blocks (the reattach region) so the breakpoint lands on the last stable
+   * block instead of a regenerated trailing image.
    */
-  addCacheControlToContentArray(contentArray) {
+  addCacheControlToContentArray(contentArray, excludeTail = 0) {
     if (contentArray.length === 0) {
       return contentArray;
     }
-    const lastItem = contentArray[contentArray.length - 1];
-    contentArray[contentArray.length - 1] = {
+    let targetIndex = contentArray.length - 1 - excludeTail;
+    if (targetIndex < 0) {
+      return contentArray;
+    }
+    if (excludeTail > 0) {
+      while (targetIndex > 0 && contentArray[targetIndex].type !== "text") {
+        targetIndex -= 1;
+      }
+    }
+    const lastItem = contentArray[targetIndex];
+    contentArray[targetIndex] = {
       ...lastItem,
       cache_control: { type: "ephemeral" }
     };

package/chunks/{chunk-BWAMMKIS.js → chunk-GYKAXTMQ.js}

@@ -1,19 +1,23 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  sanitizeFilenameForDisplay
+  sanitizeFilenameForDisplay,
+  truncateToWidth
 } from "./chunk-47ECGEJC.js";
 import {
   t
-} from "./chunk-VZUCTJ2P.js";
+} from "./chunk-I6YJZGHS.js";
 import {
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-AEY27Z35.js";
+} from "./chunk-WDH4TVD3.js";
 import {
   fetchGitDiff,
   isCompressionFailureStatus
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-KJFGH23C.js";
+import {
+  skillRestrictionNames
+} from "./chunk-NJ2OFVUX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -155,6 +159,14 @@ var computeSessionStats = /* @__PURE__ */ __name((metrics) => {
 
 // packages/cli/src/services/commandUtils.ts
 init_esbuild_shims();
+function commandRestrictionNames(cmd) {
+  const names = cmd.skillDetail ? skillRestrictionNames(cmd.skillDetail) : [cmd.name.trim().toLowerCase()];
+  return [
+    ...names,
+    ...(cmd.altNames ?? []).map((name) => name.trim().toLowerCase())
+  ];
+}
+__name(commandRestrictionNames, "commandRestrictionNames");
 function getEffectiveSupportedModes(cmd) {
   if (cmd.supportedModes !== void 0) {
     return cmd.supportedModes;
@@ -178,6 +190,104 @@ function filterCommandsForMode(commands, mode) {
 }
 __name(filterCommandsForMode, "filterCommandsForMode");
 
+// packages/cli/src/services/commandMetadata.ts
+init_esbuild_shims();
+function extensionOwnerLabel(owner) {
+  return `${t("Extension:")} ${owner.displayName || owner.name || "unknown"}`;
+}
+__name(extensionOwnerLabel, "extensionOwnerLabel");
+var MAX_EXTENSION_OWNER_LABEL_WIDTH = 35;
+function getCommandSourceBadge(command) {
+  switch (command.source) {
+    case "bundled-skill":
+      return "[Skill]";
+    case "skill-dir-command":
+      if (command.sourceDetail === "user") {
+        return "[User]";
+      }
+      if (command.sourceDetail === "project") {
+        return "[Project]";
+      }
+      return "[Custom]";
+    case "plugin-command":
+      if (command.sourceDetail !== "extension") {
+        return "[Plugin]";
+      }
+      return command.sourceLabel ? `[${truncateToWidth(command.sourceLabel, MAX_EXTENSION_OWNER_LABEL_WIDTH)}]` : "[Extension]";
+    case "mcp-prompt":
+      return "[MCP]";
+    case "builtin-command":
+    default:
+      return null;
+  }
+}
+__name(getCommandSourceBadge, "getCommandSourceBadge");
+function getCommandSourceGroup(command) {
+  switch (command.source) {
+    case "builtin-command":
+      return { key: "built-in", title: "Built-in Commands", order: 0 };
+    case "bundled-skill":
+      return { key: "bundled-skill", title: "Bundled Skills", order: 1 };
+    case "skill-dir-command":
+      return { key: "custom", title: "Custom Commands", order: 2 };
+    case "plugin-command":
+      return { key: "plugin", title: "Plugin Commands", order: 3 };
+    case "mcp-prompt":
+      return { key: "mcp", title: "MCP Commands", order: 4 };
+    default:
+      return { key: "other", title: "Other Commands", order: 5 };
+  }
+}
+__name(getCommandSourceGroup, "getCommandSourceGroup");
+function formatSupportedModes(command) {
+  const modes = getEffectiveSupportedModes(command);
+  const hasInteractive = modes.includes("interactive");
+  const hasNonInteractive = modes.includes("non_interactive");
+  const hasAcp = modes.includes("acp");
+  if (hasInteractive && hasNonInteractive && hasAcp) {
+    return "[all]";
+  }
+  if (!hasInteractive && hasNonInteractive && hasAcp) {
+    return "[headless]";
+  }
+  if (hasInteractive && !hasNonInteractive && !hasAcp) {
+    return "[interactive]";
+  }
+  return modes.map((mode) => {
+    switch (mode) {
+      case "interactive":
+        return "[i]";
+      case "non_interactive":
+        return "[ni]";
+      case "acp":
+        return "[acp]";
+      default:
+        return `[${mode}]`;
+    }
+  }).join(" ");
+}
+__name(formatSupportedModes, "formatSupportedModes");
+function getCommandDisplayName(command, options = {}) {
+  const prefix = options.prefix ?? "";
+  const baseLabel = `${prefix}${command.name}`;
+  if (options.matchedAlias) {
+    return `${baseLabel} (alias: ${options.matchedAlias})`;
+  }
+  if (options.includeAliases === false) {
+    return baseLabel;
+  }
+  const altNames = command.altNames?.filter(Boolean);
+  if (!altNames || altNames.length === 0) {
+    return baseLabel;
+  }
+  return `${baseLabel} (${altNames.join(", ")})`;
+}
+__name(getCommandDisplayName, "getCommandDisplayName");
+function getCommandSubcommandNames(command) {
+  return command.subCommands?.filter((subCommand) => !subCommand.hidden).map((subCommand) => subCommand.name) ?? [];
+}
+__name(getCommandSubcommandNames, "getCommandSubcommandNames");
+
 // packages/cli/src/ui/commands/diffCommand.ts
 init_esbuild_shims();
 async function diffAction(context) {
@@ -603,6 +713,16 @@ function levelLabel(level) {
   }
 }
 __name(levelLabel, "levelLabel");
+function skillOriginLabel(skill) {
+  if (skill.level === "extension") {
+    return `(${extensionOwnerLabel({
+      name: skill.extensionName,
+      displayName: skill.extensionDisplayName
+    })})`;
+  }
+  return `(${levelLabel(skill.level)})`;
+}
+__name(skillOriginLabel, "skillOriginLabel");
 
 export {
   INLINE_CODE_SPAN_PATTERN_SOURCE,
@@ -621,9 +741,18 @@ export {
   calculateCacheHitRate,
   computeSessionStats,
   calculateCost,
+  commandRestrictionNames,
   getEffectiveSupportedModes,
   filterCommandsForMode,
+  extensionOwnerLabel,
+  MAX_EXTENSION_OWNER_LABEL_WIDTH,
+  getCommandSourceBadge,
+  getCommandSourceGroup,
+  formatSupportedModes,
+  getCommandDisplayName,
+  getCommandSubcommandNames,
   levelLabel,
+  skillOriginLabel,
   computeDiffColumnWidths,
   diffCommand
 };
@@ -634,11 +763,11 @@ export {
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */

package/chunks/{chunk-IL5M5NYD.js → chunk-HCKYDMYV.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   formatDuration
-} from "./chunk-QMUYLYT5.js";
+} from "./chunk-YGFJ6BRT.js";
 import {
   theme
 } from "./chunk-4LIPOIXS.js";
@@ -13,18 +13,18 @@ import {
   Box_default,
   Text,
   use_is_screen_reader_enabled_default
-} from "./chunk-O4KNCAX4.js";
+} from "./chunk-NCPFOLM2.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   collectInlineImages,
   extractInlineContentRuns
-} from "./chunk-WBCPROWX.js";
+} from "./chunk-C4HBZQNH.js";
 import {
   formatHistoryGapNotice,
   indexGapsByChild
-} from "./chunk-6JACAGYH.js";
+} from "./chunk-2S2WIGCM.js";
 import {
   stringWidth
 } from "./chunk-2MIN6GRR.js";
@@ -33,24 +33,24 @@ import {
 } from "./chunk-QHTIBUWB.js";
 import {
   t
-} from "./chunk-VZUCTJ2P.js";
+} from "./chunk-I6YJZGHS.js";
 import {
   isGoalCheckpointBookkeepingRecord
-} from "./chunk-BZM5U74J.js";
+} from "./chunk-YQSC7BRZ.js";
 import {
   GoalPersistenceUnavailableError,
   getToolResponseDisplayText,
   parseGoalStateRecordPayloadV2
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-KJFGH23C.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
 import {
   projectUserTranscriptForDisplay
-} from "./chunk-E4UEO3XM.js";
+} from "./chunk-ME4JBHSB.js";
 import {
   ToolDisplayNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -3505,6 +3505,7 @@ __name(applyCollapsePolicyAndSummary, "applyCollapsePolicyAndSummary");
 export {
   SHELL_COMMAND_NAME,
   SHELL_NAME,
+  TOOL_STATUS,
   ICON,
   SPINNER_FRAMES,
   SPINNER_INTERVAL_MS,
@@ -3519,6 +3520,7 @@ export {
   STATUS_INDICATOR_WIDTH,
   ToolStatusIndicator,
   ToolElapsedTime,
+  getOverallStatus,
   isCollapsibleTool,
   estimateCompactToolGroupHeight,
   CompactToolGroupDisplay,

package/chunks/{chunk-6HUXPLB5.js → chunk-HEOH7JZY.js}

@@ -40,7 +40,7 @@ function assertSameIdentity(filePath, before, after) {
       UNVERIFIABLE_IDENTITY_CODE
     );
   }
-  if (before.dev !== after.dev || before.ino !== after.ino) {
+  if (BigInt(before.dev) !== BigInt(after.dev) || BigInt(before.ino) !== BigInt(after.ino)) {
     throw noFollowRejection(
       filePath,
       "the file identity changed between the pre-open check and the open (possible symlink race)"
@@ -58,13 +58,13 @@ function openSyncNoFollow(filePath) {
   if (typeof noFollowFlag === "number") {
     return fs.openSync(filePath, baseFlags | noFollowFlag);
   }
-  const before = fs.lstatSync(filePath);
+  const before = fs.lstatSync(filePath, { bigint: true });
   if (before.isSymbolicLink()) {
     throw noFollowRejection(filePath, "the path is a symlink");
   }
   const fd = fs.openSync(filePath, baseFlags);
   try {
-    assertSameIdentity(filePath, before, fs.fstatSync(fd));
+    assertSameIdentity(filePath, before, fs.fstatSync(fd, { bigint: true }));
   } catch (error) {
     try {
       fs.closeSync(fd);
@@ -81,13 +81,13 @@ async function openNoFollow(filePath) {
   if (typeof noFollowFlag === "number") {
     return fs.promises.open(filePath, baseFlags | noFollowFlag);
   }
-  const before = await fs.promises.lstat(filePath);
+  const before = await fs.promises.lstat(filePath, { bigint: true });
   if (before.isSymbolicLink()) {
     throw noFollowRejection(filePath, "the path is a symlink");
   }
   const handle = await fs.promises.open(filePath, baseFlags);
   try {
-    assertSameIdentity(filePath, before, await handle.stat());
+    assertSameIdentity(filePath, before, await handle.stat({ bigint: true }));
   } catch (error) {
     await handle.close().catch(() => {
     });

package/chunks/{chunk-DTNV6UZY.js → chunk-HFJSQ4GL.js}

@@ -3,10 +3,13 @@
 import {
   execCommand,
   isCommandAvailable
-} from "./chunk-JXNIF2O5.js";
+} from "./chunk-V545KI73.js";
+import {
+  resolveBundleDir
+} from "./chunk-ACHCT36C.js";
 import {
   fileExists
-} from "./chunk-J6MB5ZHZ.js";
+} from "./chunk-QZW6WRB7.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";
@@ -17,21 +20,10 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/core/src/utils/bundlePaths.ts
-init_esbuild_shims();
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-var BUNDLE_CHUNK_DIR = "chunks";
-function resolveBundleDir(importMetaUrl) {
-  const moduleDir = path.dirname(fileURLToPath(importMetaUrl));
-  return path.basename(moduleDir) === BUNDLE_CHUNK_DIR ? path.dirname(moduleDir) : moduleDir;
-}
-__name(resolveBundleDir, "resolveBundleDir");
-
 // packages/core/src/utils/ripgrepUtils.ts
 init_esbuild_shims();
-import path2 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { execFile } from "node:child_process";
 var debugLogger = createDebugLogger("RIPGREP");
 var RIPGREP_COMMAND = "rg";
@@ -45,7 +37,7 @@ function wslTimeout() {
   return process.platform === "linux" && process.env["WSL_INTEROP"] ? RIPGREP_WSL_TIMEOUT_MS : RIPGREP_RUN_TIMEOUT_MS;
 }
 __name(wslTimeout, "wslTimeout");
-var __filename = fileURLToPath2(import.meta.url);
+var __filename = fileURLToPath(import.meta.url);
 var __dirname = resolveBundleDir(import.meta.url);
 function getPlatformString(platform) {
   switch (platform) {
@@ -75,9 +67,9 @@ function getBuiltinRipgrep() {
     return null;
   }
   const binaryName = platform === "win32" ? "rg.exe" : "rg";
-  const inSrcUtils = __filename.includes(path2.join("src", "utils"));
+  const inSrcUtils = __filename.includes(path.join("src", "utils"));
   const levelsUp = !inSrcUtils ? 0 : __filename.endsWith(".ts") ? 2 : 3;
-  return path2.join(
+  return path.join(
     __dirname,
     ...Array(levelsUp).fill(".."),
     "vendor",
@@ -390,15 +382,9 @@ async function runRipgrep(args, signal, useBuiltin = true) {
 __name(runRipgrep, "runRipgrep");
 
 export {
-  resolveBundleDir,
   canUseRipgrep,
   runRipgrep
 };
-/**
- * @license
- * Copyright 2025 Qwen team
- * SPDX-License-Identifier: Apache-2.0
- */
 /**
  * @license
  * Copyright 2025 Qwen