@qwen-code/qwen-code 0.19.9 → 0.19.10-nightly.20260716.506ce0a1a

package/chunks/{chunk-D5SKC4YG.js → chunk-O3M25JXE.js}

@@ -1,14 +1,17 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
+  InvalidStreamError,
   OpenAIContentConverter,
+  ProtocolTagSanitizedEvent,
   TaggedThinkingParser,
   getRateLimitErrorDetails,
+  logProtocolTagSanitized,
   openaiRequestCaptureContext
-} from "./chunk-3VAGG5T5.js";
+} from "./chunk-YYBZUIPL.js";
 import {
   RequestTokenizer
-} from "./chunk-SJHDYNHF.js";
+} from "./chunk-4BJVSIS3.js";
 import {
   DASHSCOPE_PROXY_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
@@ -16,17 +19,18 @@ import {
   DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   MAX_STREAM_IDLE_TIMEOUT_MS,
   QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
+  resolveRequestTimeout
+} from "./chunk-FEOZBUMT.js";
+import {
   defaultOutputCeiling,
+  getToolCallPreparations,
   hasExplicitOutputLimit,
   parsePositiveIntegerEnvValue,
   reconcileMaxTokens,
-  resolveRequestTimeout,
-  tokenLimit
-} from "./chunk-524RQP4Q.js";
-import {
   runtimeDiagnostics,
-  safeJsonParse
-} from "./chunk-JSG7ZSBC.js";
+  safeJsonParse,
+  tokenLimit
+} from "./chunk-VRR65QYW.js";
 import {
   GenerateContentResponse
 } from "./chunk-4LD5APFL.js";
@@ -36,13 +40,13 @@ import {
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-4ZVWQHEQ.js";
+} from "./chunk-LQIDP6K5.js";
 import {
   createDebugLogger,
   getErrorStatus,
   getErrorType,
   isAbortError
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -7788,10 +7792,15 @@ var StreamingToolCallParser = class {
   escapes = /* @__PURE__ */ new Map();
   /** Metadata for each tool call index */
   toolCallMeta = /* @__PURE__ */ new Map();
+  namelessToolCallIndices = /* @__PURE__ */ new Set();
   /** Map from tool call ID to actual index used for storage */
   idToIndexMap = /* @__PURE__ */ new Map();
+  /** Remapped slots awaiting a stable ID from a later chunk. */
+  pendingIndexRemaps = /* @__PURE__ */ new Map();
   /** Counter for generating new indices when collisions occur */
   nextAvailableIndex = 0;
+  conflictingToolCallIdentity = false;
+  invalidToolCallIndex = false;
   /**
    * Processes a new chunk of tool call data and attempts to parse complete JSON objects
    *
@@ -7809,19 +7818,43 @@ var StreamingToolCallParser = class {
    * @returns ToolCallParseResult with completion status, parsed value, and repair info
    */
   addChunk(index, chunk, id, name) {
+    const validName = name?.trim() || void 0;
+    if (!Number.isSafeInteger(index) || index < 0) {
+      this.conflictingToolCallIdentity = true;
+      this.invalidToolCallIndex = true;
+      return {
+        complete: false,
+        error: new Error(`Invalid tool call index: ${index}`)
+      };
+    }
+    if (!id && !validName && !chunk.trim()) {
+      const depth2 = this.depths.get(index) ?? 0;
+      const inString2 = this.inStrings.get(index) ?? false;
+      if (!this.buffers.has(index) || depth2 === 0 && !inString2) {
+        return { complete: false };
+      }
+    }
     let actualIndex = index;
     const isKnownId = Boolean(id && this.idToIndexMap.has(id));
+    const existingName = this.toolCallMeta.get(index)?.name;
+    const isNameOnlyDelta = Boolean(
+      validName && chunk.length === 0 && (!existingName || existingName === validName)
+    );
     if (id) {
       if (this.idToIndexMap.has(id)) {
         actualIndex = this.idToIndexMap.get(id);
+      } else if (this.pendingIndexRemaps.has(index)) {
+        actualIndex = this.pendingIndexRemaps.get(index);
+        this.pendingIndexRemaps.delete(index);
+        this.idToIndexMap.set(id, actualIndex);
       } else {
         if (this.buffers.has(index)) {
           const existingBuffer = this.buffers.get(index);
           const existingDepth = this.depths.get(index);
           const existingMeta = this.toolCallMeta.get(index);
-          if (existingMeta?.name && existingDepth === 0 && existingMeta?.id && existingMeta.id !== id) {
-            let existingComplete = true;
-            if (existingBuffer.trim()) {
+          if (existingMeta?.id && existingMeta.id !== id) {
+            let existingComplete = existingDepth === 0;
+            if (existingComplete && existingBuffer.trim()) {
               try {
                 JSON.parse(existingBuffer);
               } catch {
@@ -7829,14 +7862,31 @@ var StreamingToolCallParser = class {
               }
             }
             if (existingComplete) {
-              actualIndex = this.findNextAvailableIndex();
+              actualIndex = 0;
+              while (this.buffers.has(actualIndex)) actualIndex += 1;
+              if (!existingMeta.name) {
+                this.conflictingToolCallIdentity = true;
+              }
+            } else {
+              this.conflictingToolCallIdentity = true;
             }
           }
         }
         this.idToIndexMap.set(id, actualIndex);
       }
-    } else {
-      if (this.buffers.has(index)) {
+    } else if (!isNameOnlyDelta) {
+      if (this.pendingIndexRemaps.has(index)) {
+        actualIndex = this.pendingIndexRemaps.get(index);
+        const existingBuffer = this.buffers.get(actualIndex);
+        const existingDepth = this.depths.get(actualIndex);
+        if (existingDepth === 0 && existingBuffer.trim()) {
+          try {
+            JSON.parse(existingBuffer);
+            actualIndex = this.findMostRecentIncompleteIndex();
+          } catch {
+          }
+        }
+      } else if (this.buffers.has(index)) {
         const existingBuffer = this.buffers.get(index);
         const existingDepth = this.depths.get(index);
         if (existingDepth > 0 || !existingBuffer.trim()) {
@@ -7860,6 +7910,20 @@ var StreamingToolCallParser = class {
     }
     const currentBuffer = this.buffers.get(actualIndex);
     const currentDepth = this.depths.get(actualIndex);
+    const meta = this.toolCallMeta.get(actualIndex);
+    if (chunk.length === 0 && (id || validName)) {
+      if (id) meta.id = id;
+      if (validName && !meta.name) meta.name = validName;
+      if (!meta.name && meta.id) {
+        this.namelessToolCallIndices.add(actualIndex);
+      } else {
+        this.namelessToolCallIndices.delete(actualIndex);
+      }
+      if (!meta.id && actualIndex !== index) {
+        this.pendingIndexRemaps.set(index, actualIndex);
+      }
+      return { actualIndex, complete: false };
+    }
     if (isKnownId && currentDepth === 0) {
       if (currentBuffer.trim()) {
         try {
@@ -7867,23 +7931,32 @@ var StreamingToolCallParser = class {
           debugLogger3.debug(
             `Ignoring replay chunk for completed toolCall id=${id}`
           );
-          return { complete: false };
+          return { actualIndex, complete: false };
         } catch {
         }
-      } else if (this.toolCallMeta.get(actualIndex)?.name && name && !chunk.trim()) {
-        debugLogger3.debug(
-          `Ignoring replayed opener for no-argument toolCall id=${id}`
-        );
-        return { complete: false };
       }
     }
-    const meta = this.toolCallMeta.get(actualIndex);
+    const identityChanged = Boolean(id && meta.id && meta.id !== id);
     if (id) meta.id = id;
-    if (name) meta.name = name;
+    if (validName) {
+      if (!identityChanged && meta.name && meta.name !== validName) {
+        this.conflictingToolCallIdentity = true;
+      } else {
+        meta.name = validName;
+      }
+    }
+    if (!meta.id && actualIndex !== index) {
+      this.pendingIndexRemaps.set(index, actualIndex);
+    }
     const currentInString = this.inStrings.get(actualIndex);
     const currentEscape = this.escapes.get(actualIndex);
     const newBuffer = currentBuffer + chunk;
     this.buffers.set(actualIndex, newBuffer);
+    if (!meta.name && (meta.id || /\S/.test(newBuffer))) {
+      this.namelessToolCallIndices.add(actualIndex);
+    } else {
+      this.namelessToolCallIndices.delete(actualIndex);
+    }
     let depth = currentDepth;
     let inString = currentInString;
     let escape2 = currentEscape;
@@ -7903,12 +7976,13 @@ var StreamingToolCallParser = class {
     if (depth === 0 && newBuffer.trim().length > 0) {
       try {
         const parsed = JSON.parse(newBuffer);
-        return { complete: true, value: parsed };
+        return { actualIndex, complete: true, value: parsed };
       } catch (e) {
         if (inString) {
           try {
             const repaired = JSON.parse(newBuffer + '"');
             return {
+              actualIndex,
               complete: true,
               value: repaired,
               repaired: true
@@ -7917,12 +7991,13 @@ var StreamingToolCallParser = class {
           }
         }
         return {
+          actualIndex,
           complete: false,
           error: e instanceof Error ? e : new Error(String(e))
         };
       }
     }
-    return { complete: false };
+    return { actualIndex, complete: false };
   }
   /**
    * Gets the current tool call metadata for a specific index
@@ -7933,6 +8008,29 @@ var StreamingToolCallParser = class {
   getToolCallMeta(index) {
     return this.toolCallMeta.get(index) || {};
   }
+  hasNamelessToolCall() {
+    return this.namelessToolCallIndices.size > 0;
+  }
+  hasConflictingToolCallIdentity() {
+    return this.conflictingToolCallIdentity;
+  }
+  hasInvalidToolCallIndex() {
+    return this.invalidToolCallIndex;
+  }
+  hasInvalidToolCallArguments() {
+    for (const [index, buffer] of this.buffers.entries()) {
+      if (!this.toolCallMeta.get(index)?.name || buffer.length === 0) continue;
+      try {
+        const args = JSON.parse(buffer);
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+          return true;
+        }
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  }
   /**
    * Gets all completed tool calls that are ready to be emitted
    *
@@ -8064,6 +8162,12 @@ var StreamingToolCallParser = class {
     this.inStrings.set(index, false);
     this.escapes.set(index, false);
     this.toolCallMeta.set(index, {});
+    this.namelessToolCallIndices.delete(index);
+    for (const [providerIndex, actualIndex] of this.pendingIndexRemaps) {
+      if (providerIndex === index || actualIndex === index) {
+        this.pendingIndexRemaps.delete(providerIndex);
+      }
+    }
   }
   /**
    * Resets the entire parser state for processing a new stream
@@ -8078,8 +8182,12 @@ var StreamingToolCallParser = class {
     this.inStrings.clear();
     this.escapes.clear();
     this.toolCallMeta.clear();
+    this.namelessToolCallIndices.clear();
     this.idToIndexMap.clear();
+    this.pendingIndexRemaps.clear();
     this.nextAvailableIndex = 0;
+    this.conflictingToolCallIdentity = false;
+    this.invalidToolCallIndex = false;
   }
   /**
    * Gets the current accumulated buffer content for a specific index
@@ -8380,7 +8488,8 @@ var ContentGenerationPipeline = class {
         const innerStream = this.processStreamWithLogging(
           guarded,
           context,
-          request
+          request,
+          userPromptId
         );
         async function* drainThenCleanup() {
           try {
@@ -8403,10 +8512,29 @@ var ContentGenerationPipeline = class {
    * 4. Collect both formats for logging
    * 5. Handle success/error logging
    */
-  async *processStreamWithLogging(stream, context, request) {
+  async *processStreamWithLogging(stream, context, request, userPromptId) {
     const collectedGeminiResponses = [];
     let pendingFinishResponse = null;
     let finishYielded = false;
+    let pendingFinishProtocolTagSanitized;
+    const logPendingProtocolTagSanitized = /* @__PURE__ */ __name((response, sanitization) => {
+      if (!sanitization) return;
+      const event = new ProtocolTagSanitizedEvent({
+        model: context.model,
+        promptId: userPromptId,
+        responseId: response.responseId,
+        tagName: sanitization.tagName,
+        toolCallCount: sanitization.toolCallCount
+      });
+      debugLogger4.warn("Sanitized a model protocol tag", {
+        model: event.model,
+        promptId: event.prompt_id,
+        responseId: event.response_id,
+        tagName: event.tag_name,
+        toolCallCount: event.tool_call_count
+      });
+      logProtocolTagSanitized(this.config.cliConfig, event);
+    }, "logPendingProtocolTagSanitized");
     try {
       for await (const chunk of stream) {
         if (chunk.choices?.[0]?.finish_reason === "error_finish") {
@@ -8417,9 +8545,22 @@ var ContentGenerationPipeline = class {
           chunk,
           context
         );
-        if (response.candidates?.[0]?.content?.parts?.length === 0 && !response.candidates?.[0]?.finishReason && !response.usageMetadata) {
+        const sanitization = context.protocolTagSanitized;
+        if (sanitization) {
+          context.protocolTagSanitized = void 0;
+        }
+        if (response.candidates?.[0]?.content?.parts?.length === 0 && !response.candidates?.[0]?.finishReason && !response.usageMetadata && // Preparation-only responses must reach ACP before arguments complete.
+        getToolCallPreparations(response).length === 0) {
           continue;
         }
+        if (pendingFinishProtocolTagSanitized && pendingFinishResponse && !response.candidates?.[0]?.finishReason && response.candidates?.some(
+          (candidate) => (candidate.content?.parts?.length ?? 0) > 0
+        )) {
+          throw new InvalidStreamError(
+            "Model response continued after a finish reason.",
+            "PROTOCOL_TAG_LEAK"
+          );
+        }
         if (finishYielded) {
           if (response.usageMetadata) {
             const pending = pendingFinishResponse;
@@ -8430,6 +8571,9 @@ var ContentGenerationPipeline = class {
           collectedGeminiResponses.push(response);
           continue;
         }
+        if (!pendingFinishResponse && response.candidates?.[0]?.finishReason && sanitization) {
+          pendingFinishProtocolTagSanitized = sanitization;
+        }
         const shouldYield = this.handleChunkMerging(
           response,
           collectedGeminiResponses,
@@ -8439,20 +8583,60 @@ var ContentGenerationPipeline = class {
         );
         if (shouldYield) {
           if (pendingFinishResponse) {
+            logPendingProtocolTagSanitized(
+              pendingFinishResponse,
+              pendingFinishProtocolTagSanitized
+            );
             yield pendingFinishResponse;
             finishYielded = true;
           } else {
+            logPendingProtocolTagSanitized(response, sanitization);
             yield response;
           }
         }
       }
+      if (context.pendingThinkingTagCandidate && !context.pendingThinkingTagCandidate.closingTagName && !/\S/.test(context.pendingThinkingTagCandidate.text)) {
+        const pendingParts = context.pendingUntrustedResponseParts;
+        context.pendingThinkingTagCandidate = void 0;
+        context.pendingUntrustedResponseParts = void 0;
+        if (pendingParts?.length) {
+          const response = new GenerateContentResponse();
+          response.candidates = [
+            {
+              content: { parts: pendingParts, role: "model" },
+              index: 0
+            }
+          ];
+          yield response;
+        }
+      } else if (context.pendingThinkingTagCandidate) {
+        throw new InvalidStreamError(
+          "Model response leaked thinking tags.",
+          "PROTOCOL_TAG_LEAK"
+        );
+      }
       if (pendingFinishResponse && !finishYielded) {
+        logPendingProtocolTagSanitized(
+          pendingFinishResponse,
+          pendingFinishProtocolTagSanitized
+        );
         yield pendingFinishResponse;
       }
     } catch (error) {
+      if (error instanceof InvalidStreamError) {
+        throw error;
+      }
       if (error instanceof StreamContentError) {
         throw redactProxyError(error);
       }
+      if (context.pendingThinkingTagCandidate?.closingTagName && request.config?.abortSignal?.aborted !== true) {
+        context.pendingThinkingTagCandidate = void 0;
+        context.pendingUntrustedResponseParts = void 0;
+        throw new InvalidStreamError(
+          "Model response leaked thinking tags.",
+          "PROTOCOL_TAG_LEAK"
+        );
+      }
       if (error instanceof StreamInactivityTimeoutError) {
         debugLogger4.warn("OpenAI stream inactivity timeout", {
           idleMs: error.idleMs,

package/chunks/{chunk-EAXLGSFP.js → chunk-O6XGHDS5.js}

@@ -6,29 +6,29 @@ import {
   parseAcpBaseModelId,
   resolveCliGenerationConfig,
   sanitizeProviderBaseUrl
-} from "./chunk-34MW4KTI.js";
+} from "./chunk-BA5JGE5F.js";
 import {
   snapshotProcessEnv
-} from "./chunk-XLA62MYB.js";
+} from "./chunk-KXECVZPD.js";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-VWPVHAMO.js";
+} from "./chunk-XIWQ5QST.js";
 import {
   loadSettings
-} from "./chunk-4C5BQ2D2.js";
+} from "./chunk-TIKDHS6V.js";
 import {
   ModelsConfig,
   resolveProviderProtocol
-} from "./chunk-NVYTCB5Z.js";
+} from "./chunk-SA6QVLWI.js";
 import {
   APPROVAL_MODES
-} from "./chunk-4GORAUCN.js";
+} from "./chunk-F333XEAU.js";
 import {
   tokenLimit
-} from "./chunk-524RQP4Q.js";
+} from "./chunk-VRR65QYW.js";
 import {
   createDebugLogger
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -168,7 +168,7 @@ function buildWorkspaceProvidersStatus(workspaceCwd, acpChannelLive, options) {
 __name(buildWorkspaceProvidersStatus, "buildWorkspaceProvidersStatus");
 function resolveApprovalMode(settings) {
   const value = settings.tools?.approvalMode;
-  if (typeof value !== "string") return "default" /* DEFAULT */;
+  if (typeof value !== "string") return "auto" /* AUTO */;
   const normalized = value.trim().toLowerCase().replaceAll("_", "-");
   const mode = normalized === "autoedit" ? "auto-edit" /* AUTO_EDIT */ : normalized;
   if (APPROVAL_MODES.includes(mode)) {
@@ -176,10 +176,10 @@ function resolveApprovalMode(settings) {
   }
   if (value.trim().length > 0) {
     debugLogger.warn(
-      `[workspace-providers-status] unrecognized approvalMode "${value}", falling back to default`
+      `[workspace-providers-status] unrecognized approvalMode "${value}", falling back to auto`
     );
   }
-  return "default" /* DEFAULT */;
+  return "auto" /* AUTO */;
 }
 __name(resolveApprovalMode, "resolveApprovalMode");
 function isMainSelectableModel(model) {

package/chunks/{chunk-WL4L7EZH.js → chunk-OA4JVLSA.js}

@@ -33,10 +33,36 @@ var WorkspacePermissionRulesSessionRequiredError = class extends Error {
     this.name = "WorkspacePermissionRulesSessionRequiredError";
   }
 };
+var WorkspaceSkillNotFoundError = class extends Error {
+  constructor(skillName) {
+    super(`Skill not found: ${skillName}`);
+    this.skillName = skillName;
+    this.name = "WorkspaceSkillNotFoundError";
+  }
+  static {
+    __name(this, "WorkspaceSkillNotFoundError");
+  }
+};
+var WorkspaceSkillNotToggleableError = class extends Error {
+  constructor(skillName, reason, lockedScope) {
+    super(
+      lockedScope ? `Skill ${skillName} is locked by ${lockedScope} settings` : `Skill ${skillName} is not toggleable: ${reason}`
+    );
+    this.skillName = skillName;
+    this.reason = reason;
+    this.lockedScope = lockedScope;
+    this.name = "WorkspaceSkillNotToggleableError";
+  }
+  static {
+    __name(this, "WorkspaceSkillNotToggleableError");
+  }
+};
 
 export {
   WorkspaceSettingsPartialPersistError,
-  WorkspacePermissionRulesSessionRequiredError
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSkillNotFoundError,
+  WorkspaceSkillNotToggleableError
 };
 /**
  * @license

package/chunks/{chunk-X4NKFGFJ.js → chunk-OJAMDVF5.js}

@@ -7,15 +7,6 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/cli/src/serve/channel-worker-env.ts
-init_esbuild_shims();
-var CHANNEL_DAEMON_WORKER_SENTINEL = "QWEN_CHANNEL_DAEMON_WORKER";
-var CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS = 15e3;
-var QWEN_DAEMON_TOKEN_ENV = "QWEN_DAEMON_TOKEN";
-var QWEN_DAEMON_URL_ENV = "QWEN_DAEMON_URL";
-var QWEN_DAEMON_WORKSPACE_ENV = "QWEN_DAEMON_WORKSPACE";
-var QWEN_SERVER_TOKEN_ENV = "QWEN_SERVER_TOKEN";
-
 // packages/cli/src/serve/channel-webhook-ipc.ts
 init_esbuild_shims();
 import { randomUUID } from "node:crypto";
@@ -65,12 +56,6 @@ function isChannelWebhookTaskResultMessage(value) {
 __name(isChannelWebhookTaskResultMessage, "isChannelWebhookTaskResultMessage");
 
 export {
-  CHANNEL_DAEMON_WORKER_SENTINEL,
-  CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS,
-  QWEN_DAEMON_TOKEN_ENV,
-  QWEN_DAEMON_URL_ENV,
-  QWEN_DAEMON_WORKSPACE_ENV,
-  QWEN_SERVER_TOKEN_ENV,
   ChannelWebhookEnqueueError,
   isChannelWebhookEnqueueErrorCode,
   isChannelWebhookEnqueueError,

package/chunks/{chunk-BZIFY5TF.js → chunk-OKAIGAYW.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   formatFetchErrorForUser
-} from "./chunk-UOZWKTQG.js";
+} from "./chunk-ZPAHLFZU.js";
 import {
   openBrowserSecurely
 } from "./chunk-JESCGQM3.js";
 import {
   atomicWriteFile
-} from "./chunk-ZLXQN2QS.js";
+} from "./chunk-WIEO4CWB.js";
 import {
   combineAbortSignals
 } from "./chunk-DJ2GSRLV.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-CNEIYWSA.js → chunk-OVIV236K.js}

@@ -1,14 +1,14 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  is_in_ci_default
+} from "./chunk-NHDKSOEY.js";
 import {
   require_react
 } from "./chunk-HTHUX2T5.js";
 import {
   themeManager
-} from "./chunk-MXL5UP4X.js";
-import {
-  is_in_ci_default
-} from "./chunk-NHDKSOEY.js";
+} from "./chunk-Q6TUALBE.js";
 import {
   eastAsianWidth,
   isFullWidth,
@@ -16,7 +16,7 @@ import {
 } from "./chunk-QHTIBUWB.js";
 import {
   stripAnsi
-} from "./chunk-NVYTCB5Z.js";
+} from "./chunk-SA6QVLWI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-3SJSQXNS.js → chunk-PEJWA3QQ.js}

@@ -1,26 +1,30 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  SETTINGS_DIRECTORY_NAME,
   V1_INDICATOR_KEYS,
+  resolveEnvVarsInObject
+} from "./chunk-GOXKNSDZ.js";
+import {
+  SETTINGS_DIRECTORY_NAME,
   getGlobalQwenDirLite,
   getSystemDefaultsPath,
-  getSystemSettingsPath,
-  resolveEnvVarsInObject
-} from "./chunk-3BTRNWWD.js";
+  getSystemSettingsPath
+} from "./chunk-IDS7MSUP.js";
 import {
   DEFAULT_EXCLUDED_ENV_VARS,
   HOME_ENV_BOOTSTRAP_KEYS,
   PROJECT_ENV_HARDCODED_EXCLUSIONS
 } from "./chunk-QRUIS3DN.js";
 import {
-  getPathComparisonVariants,
-  isWithinRoot,
   require_strip_json_comments
-} from "./chunk-RDJSGHZE.js";
+} from "./chunk-ALGGS7UH.js";
+import {
+  getPathComparisonVariants,
+  isWithinRoot
+} from "./chunk-MR3PXB6E.js";
 import {
   require_main
-} from "./chunk-ZJE7NSL3.js";
+} from "./chunk-5M6IDOMF.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";