@qwen-code/qwen-code 0.22.3 → 0.23.0

package/chunks/chunk-ZJ2LM2SI.js

@@ -0,0 +1,198 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  REASONING_EFFORT_TIERS
+} from "./chunk-2LD5U7Q3.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/acp-integration/model-configuration.ts
+init_esbuild_shims();
+var MODEL_CONFIGURATIONS = {
+  "qwen3.5-plus": {
+    reasoning: { thinking: true, toggleOnly: true }
+  },
+  "qwen3.6-plus": {
+    reasoning: { thinking: true, toggleOnly: true }
+  },
+  "qwen3.6-flash": {
+    reasoning: { thinking: true, toggleOnly: true }
+  },
+  "qwen3.7-plus": {
+    reasoning: { thinking: true, toggleOnly: true }
+  },
+  "qwen3.7-max": {
+    reasoning: { thinking: true, toggleOnly: true }
+  },
+  "qwen3.8-max": {
+    reasoning: {
+      thinking: true,
+      efforts: ["low", "medium", "xhigh"],
+      defaultEffort: "xhigh"
+    }
+  }
+};
+var REASONING_EFFORT_DEFAULT = "default";
+var REASONING_EFFORT_NONE = "none";
+var PERSIST_REASONING_SELECTION_META_KEY = "qwenCode/persistReasoningSelection";
+var REASONING_SELECTION_PERSISTED_META_KEY = "qwenCode/reasoningSelectionPersisted";
+var REASONING_EFFORT_NAMES = {
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra high",
+  max: "Max"
+};
+function resolvePersistedReasoningConfigState(modelId, value, thinkingMandatory = false) {
+  const selection = parseReasoningSelection(value);
+  if (!selection || selection === REASONING_EFFORT_DEFAULT || !isReasoningSelectionSupported(modelId, selection, thinkingMandatory)) {
+    return { thinkingMandatory };
+  }
+  return selection === REASONING_EFFORT_NONE ? { enabled: false, thinkingMandatory } : { enabled: true, effort: selection, thinkingMandatory };
+}
+__name(resolvePersistedReasoningConfigState, "resolvePersistedReasoningConfigState");
+function getModelConfiguration(modelId) {
+  return modelId ? MODEL_CONFIGURATIONS[modelId] : void 0;
+}
+__name(getModelConfiguration, "getModelConfiguration");
+function parseReasoningSelection(value) {
+  if (value === REASONING_EFFORT_NONE || value === REASONING_EFFORT_DEFAULT) {
+    return value;
+  }
+  return REASONING_EFFORT_TIERS.find((tier) => tier === value);
+}
+__name(parseReasoningSelection, "parseReasoningSelection");
+function isReasoningSelectionSupported(modelId, selection, thinkingMandatory = false) {
+  if (!modelId) return false;
+  const reasoning = getModelConfiguration(modelId)?.reasoning;
+  if (!reasoning?.thinking) {
+    const normalized = modelId.toLowerCase();
+    if (normalized.startsWith("qwen") || normalized === "coder-model")
+      return false;
+  }
+  if (selection === REASONING_EFFORT_DEFAULT) return true;
+  if (selection === REASONING_EFFORT_NONE) return !thinkingMandatory;
+  return reasoning?.thinking ? !reasoning.toggleOnly && reasoning.efforts.includes(selection) : REASONING_EFFORT_TIERS.includes(selection);
+}
+__name(isReasoningSelectionSupported, "isReasoningSelectionSupported");
+function clearReasoningRequestOverrides(generation) {
+  for (const source of ["extra_body", "samplingParams"]) {
+    const layer = generation[source];
+    if (!layer) continue;
+    const next = { ...layer };
+    delete next["enable_thinking"];
+    delete next["reasoning_effort"];
+    delete next["thinking_budget"];
+    generation[source] = next;
+  }
+}
+__name(clearReasoningRequestOverrides, "clearReasoningRequestOverrides");
+function applyReasoningSelection(config, selection, defaultReasoning) {
+  const apply = /* @__PURE__ */ __name((generation) => {
+    if (!generation) return;
+    if (selection === REASONING_EFFORT_NONE) {
+      generation.reasoning = false;
+      return;
+    }
+    if (selection === REASONING_EFFORT_DEFAULT) {
+      if (defaultReasoning !== void 0) {
+        generation.reasoning = defaultReasoning ? { ...defaultReasoning } : false;
+        return;
+      }
+      if (!generation.reasoning) {
+        generation.reasoning = void 0;
+        return;
+      }
+      const next = { ...generation.reasoning };
+      delete next.effort;
+      generation.reasoning = Object.keys(next).length > 0 ? next : void 0;
+      return;
+    }
+    generation.reasoning = {
+      ...generation.reasoning || defaultReasoning || {},
+      effort: selection
+    };
+  }, "apply");
+  const live = config.getContentGeneratorConfig?.();
+  apply(live);
+  const modelsConfig = config.getModelsConfig?.();
+  const rebuildable = modelsConfig?.getGenerationConfig?.();
+  if (rebuildable !== live) apply(rebuildable);
+}
+__name(applyReasoningSelection, "applyReasoningSelection");
+function buildModelReasoningConfigOption(modelId, state = {}) {
+  const reasoning = getModelConfiguration(modelId)?.reasoning;
+  if (!reasoning?.thinking) return void 0;
+  const thinkingMandatory = state.thinkingMandatory === true;
+  const currentValue = state.enabled === false && !thinkingMandatory ? REASONING_EFFORT_NONE : reasoning.toggleOnly ? REASONING_EFFORT_DEFAULT : reasoning.efforts.find((effort) => effort === state.effort) ?? reasoning.defaultEffort;
+  return {
+    id: "reasoning_effort",
+    name: "Reasoning effort",
+    description: `Thinking and reasoning effort for ${modelId}`,
+    category: "thought_level",
+    type: "select",
+    currentValue,
+    options: [
+      ...thinkingMandatory ? [] : [
+        {
+          value: REASONING_EFFORT_NONE,
+          name: "Thinking off",
+          description: "Disable thinking for this session"
+        }
+      ],
+      ...reasoning.toggleOnly ? [
+        {
+          value: REASONING_EFFORT_DEFAULT,
+          name: "Thinking on",
+          description: "Use the model or provider thinking default"
+        }
+      ] : reasoning.efforts.map((effort) => ({
+        value: effort,
+        name: REASONING_EFFORT_NAMES[effort],
+        description: "Apply this effort to the next request"
+      }))
+    ],
+    _meta: {
+      "qwenCode/reasoning": reasoning.toggleOnly ? {
+        toggleOnly: true,
+        ...thinkingMandatory ? { thinkingMandatory: true } : {}
+      } : {
+        defaultEffort: reasoning.defaultEffort,
+        ...thinkingMandatory ? { thinkingMandatory: true } : {}
+      }
+    }
+  };
+}
+__name(buildModelReasoningConfigOption, "buildModelReasoningConfigOption");
+function buildModelReasoningConfigPreview(modelId, state = {}) {
+  const reasoning = getModelConfiguration(modelId)?.reasoning;
+  if (!reasoning?.thinking) return void 0;
+  const option = buildModelReasoningConfigOption(modelId, state);
+  return option ? [option] : void 0;
+}
+__name(buildModelReasoningConfigPreview, "buildModelReasoningConfigPreview");
+
+export {
+  REASONING_EFFORT_DEFAULT,
+  REASONING_EFFORT_NONE,
+  PERSIST_REASONING_SELECTION_META_KEY,
+  REASONING_SELECTION_PERSISTED_META_KEY,
+  REASONING_EFFORT_NAMES,
+  resolvePersistedReasoningConfigState,
+  getModelConfiguration,
+  parseReasoningSelection,
+  isReasoningSelectionSupported,
+  clearReasoningRequestOverrides,
+  applyReasoningSelection,
+  buildModelReasoningConfigOption,
+  buildModelReasoningConfigPreview
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-AYFA7MZV.js → chunk-ZKFTS3OV.js}

@@ -2,25 +2,25 @@
 "use strict";
 import {
   recordGrepResultFileReads
-} from "./chunk-XQFT3QUF.js";
+} from "./chunk-ENYUKMFK.js";
 import {
   runRipgrep
-} from "./chunk-4K7KNVWH.js";
+} from "./chunk-VYIUNFEA.js";
 import {
   RipgrepRuntimeRecoveryEvent,
   logRipgrepRuntimeRecovery
-} from "./chunk-QYMAKPY5.js";
+} from "./chunk-GH2S4GD5.js";
 import {
   DEFAULT_FILE_FILTERING_OPTIONS,
   QwenIgnoreParser,
   getQwenIgnoreFileNames
-} from "./chunk-PDQGMSZK.js";
+} from "./chunk-ODZF64DM.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   SchemaValidator,
   ToolNames
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   createDebugLogger,
   formatDisplayPath,
@@ -28,7 +28,7 @@ import {
   resolveAndValidatePath,
   resolvePath,
   unescapePath
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-HMJ2P3SV.js → chunk-ZL4HFSL6.js}

@@ -2,9 +2,10 @@
 "use strict";
 import {
   require_call_bind_apply_helpers,
+  require_es_define_property,
   require_get_intrinsic,
   require_type
-} from "./chunk-7E7UCJHS.js";
+} from "./chunk-OSHQMOBS.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -650,9 +651,8 @@ var require_side_channel_list = __commonJS({
           }
         }, "assert"),
         "delete": /* @__PURE__ */ __name(function(key) {
-          var root = $o && $o.next;
           var deletedNode = listDelete($o, key);
-          if (deletedNode && root && root === deletedNode) {
+          if (deletedNode && $o && !$o.next) {
             $o = void 0;
           }
           return !!deletedNode;
@@ -853,7 +853,8 @@ var require_side_channel = __commonJS({
       var channel = {
         assert: /* @__PURE__ */ __name(function(key) {
           if (!channel.has(key)) {
-            throw new $TypeError("Side channel does not contain " + inspect(key));
+            var keyDesc = key && Object(key) === key ? "the given object key" : inspect(key);
+            throw new $TypeError("Side channel does not contain " + keyDesc);
           }
         }, "assert"),
         "delete": /* @__PURE__ */ __name(function(key) {
@@ -911,6 +912,7 @@ var require_utils = __commonJS({
     init_esbuild_shims();
     var formats = require_formats();
     var getSideChannel = require_side_channel();
+    var defineProperty = require_es_define_property();
     var has = Object.prototype.hasOwnProperty;
     var isArray = Array.isArray;
     var overflowChannel = getSideChannel();
@@ -958,6 +960,18 @@ var require_utils = __commonJS({
       }
       return obj;
     }, "arrayToObject");
+    var setProperty = /* @__PURE__ */ __name(function setProperty2(obj, key, value) {
+      if (key === "__proto__" && defineProperty) {
+        defineProperty(obj, key, {
+          configurable: true,
+          enumerable: true,
+          value,
+          writable: true
+        });
+      } else {
+        obj[key] = value;
+      }
+    }, "setProperty");
     var merge = /* @__PURE__ */ __name(function merge2(target, source, options) {
       if (!source) {
         return target;
@@ -965,7 +979,10 @@ var require_utils = __commonJS({
       if (typeof source !== "object" && typeof source !== "function") {
         if (isArray(target)) {
           var nextIndex = target.length;
-          if (options && typeof options.arrayLimit === "number" && nextIndex > options.arrayLimit) {
+          if (options && typeof options.arrayLimit === "number" && nextIndex >= options.arrayLimit) {
+            if (options.throwOnLimitExceeded) {
+              throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+            }
             return markOverflow(arrayToObject(target.concat(source), options), nextIndex);
           }
           target[nextIndex] = source;
@@ -996,6 +1013,9 @@ var require_utils = __commonJS({
         }
         var combined = [target].concat(source);
         if (options && typeof options.arrayLimit === "number" && combined.length > options.arrayLimit) {
+          if (options.throwOnLimitExceeded) {
+            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+          }
           return markOverflow(arrayToObject(combined, options), combined.length - 1);
         }
         return combined;
@@ -1017,14 +1037,20 @@ var require_utils = __commonJS({
             target[i] = item;
           }
         });
+        if (options && typeof options.arrayLimit === "number" && target.length > options.arrayLimit) {
+          if (options.throwOnLimitExceeded) {
+            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+          }
+          return markOverflow(arrayToObject(target, options), target.length - 1);
+        }
         return target;
       }
       return Object.keys(source).reduce(function(acc, key) {
         var value = source[key];
         if (has.call(acc, key)) {
-          acc[key] = merge2(acc[key], value, options);
+          setProperty(acc, key, merge2(acc[key], value, options));
         } else {
-          acc[key] = value;
+          setProperty(acc, key, value);
         }
         if (isOverflow(source) && !isOverflow(acc)) {
           markOverflow(acc, getMaxIndex(source));
@@ -1040,7 +1066,7 @@ var require_utils = __commonJS({
     }, "merge");
     var assign = /* @__PURE__ */ __name(function assignSingleSource(target, source) {
       return Object.keys(source).reduce(function(acc, key) {
-        acc[key] = source[key];
+        setProperty(acc, key, source[key]);
         return acc;
       }, target);
     }, "assignSingleSource");
@@ -1074,6 +1100,13 @@ var require_utils = __commonJS({
       var out = "";
       for (var j = 0; j < string.length; j += limit) {
         var segment = string.length >= limit ? string.slice(j, j + limit) : string;
+        if (j + limit < string.length) {
+          var last = segment.charCodeAt(segment.length - 1);
+          if (last >= 55296 && last <= 56319) {
+            segment = segment.slice(0, -1);
+            j -= 1;
+          }
+        }
         var arr = [];
         for (var i = 0; i < segment.length; ++i) {
           var c = segment.charCodeAt(i);
@@ -1103,7 +1136,7 @@ var require_utils = __commonJS({
     }, "encode");
     var compact = /* @__PURE__ */ __name(function compact2(value) {
       var queue = [{ obj: { o: value }, prop: "o" }];
-      var refs = [];
+      var refs = getSideChannel();
       for (var i = 0; i < queue.length; ++i) {
         var item = queue[i];
         var obj = item.obj[item.prop];
@@ -1111,9 +1144,9 @@ var require_utils = __commonJS({
         for (var j = 0; j < keys.length; ++j) {
           var key = keys[j];
           var val = obj[key];
-          if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
+          if (typeof val === "object" && val !== null && !refs.has(val)) {
             queue[queue.length] = { obj, prop: key };
-            refs[refs.length] = val;
+            refs.set(val, true);
           }
         }
       }
@@ -1127,17 +1160,27 @@ var require_utils = __commonJS({
       if (!obj || typeof obj !== "object") {
         return false;
       }
-      return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+      return !!(obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj));
     }, "isBuffer");
-    var combine = /* @__PURE__ */ __name(function combine2(a, b, arrayLimit, plainObjects) {
+    var combine = /* @__PURE__ */ __name(function combine2(a, b, arrayLimit, plainObjects, throwOnLimitExceeded) {
       if (isOverflow(a)) {
-        var newIndex = getMaxIndex(a) + 1;
-        a[newIndex] = b;
+        if (throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + arrayLimit + " element" + (arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        }
+        var bValues = isArray(b) ? b : [b];
+        var newIndex = getMaxIndex(a);
+        for (var i = 0; i < bValues.length; ++i) {
+          newIndex += 1;
+          a[newIndex] = bValues[i];
+        }
         setMaxIndex(a, newIndex);
         return a;
       }
       var result = [].concat(a, b);
       if (result.length > arrayLimit) {
+        if (throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + arrayLimit + " element" + (arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        }
         return markOverflow(arrayToObject(result, { plainObjects }), result.length - 1);
       }
       return result;
@@ -1206,6 +1249,7 @@ var require_stringify = __commonJS({
       charsetSentinel: false,
       commaRoundTrip: false,
       delimiter: "&",
+      depth: Infinity,
       encode: true,
       encodeDotInKeys: false,
       encoder: utils.encode,
@@ -1225,8 +1269,11 @@ var require_stringify = __commonJS({
       return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
     }, "isNonNullishPrimitive");
     var sentinel = {};
-    var stringify = /* @__PURE__ */ __name(function stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) {
+    var stringify = /* @__PURE__ */ __name(function stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel, depth, currentDepth) {
       var obj = object;
+      if (currentDepth > depth) {
+        throw new RangeError("Input depth exceeded depth option of " + depth);
+      }
       var tmpSc = sideChannel;
       var step = 0;
       var findFlag = false;
@@ -1244,9 +1291,8 @@ var require_stringify = __commonJS({
           step = 0;
         }
       }
-      if (typeof filter === "function") {
-        obj = filter(prefix, obj);
-      } else if (obj instanceof Date) {
+      obj = typeof filter === "function" ? filter(prefix, obj) : obj;
+      if (obj instanceof Date) {
         obj = serializeDate(obj);
       } else if (generateArrayPrefix === "comma" && isArray(obj)) {
         obj = utils.maybeMap(obj, function(value2) {
@@ -1289,7 +1335,7 @@ var require_stringify = __commonJS({
       }
       var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix);
       var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix;
-      if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+      if (allowEmptyArrays && isArray(obj) && obj.length === 0 && Object.keys(obj).length === 0) {
         return adjustedPrefix + "[]";
       }
       for (var j = 0; j < objKeys.length; ++j) {
@@ -1321,7 +1367,9 @@ var require_stringify = __commonJS({
           formatter,
           encodeValuesOnly,
           charset,
-          valueSideChannel
+          valueSideChannel,
+          depth,
+          currentDepth + 1
         ));
       }
       return values;
@@ -1376,6 +1424,7 @@ var require_stringify = __commonJS({
         charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
         commaRoundTrip: !!opts.commaRoundTrip,
         delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
+        depth: typeof opts.depth === "number" ? opts.depth : defaults.depth,
         encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
         encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
         encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
@@ -1423,9 +1472,10 @@ var require_stringify = __commonJS({
         if (options.skipNulls && value === null) {
           continue;
         }
+        var encodedKey = options.encodeDotInKeys ? String(key).replace(/\./g, "%2E") : String(key);
         pushToArray(keys, stringify(
           value,
-          key,
+          encodedKey,
           generateArrayPrefix,
           commaRoundTrip,
           options.allowEmptyArrays,
@@ -1441,7 +1491,9 @@ var require_stringify = __commonJS({
           options.formatter,
           options.encodeValuesOnly,
           options.charset,
-          sideChannel
+          sideChannel,
+          options.depth,
+          0
         ));
       }
       var joined = keys.join(options.delimiter);
@@ -1497,6 +1549,17 @@ var require_parse = __commonJS({
     }, "interpretNumericEntities");
     var parseArrayValue = /* @__PURE__ */ __name(function(val, options, currentArrayLength) {
       if (val && typeof val === "string" && options.comma && val.indexOf(",") > -1) {
+        if (options.throwOnLimitExceeded) {
+          var commaCount = 0;
+          var commaIndex = val.indexOf(",");
+          while (commaIndex > -1) {
+            commaCount += 1;
+            if (commaCount >= options.arrayLimit) {
+              throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+            }
+            commaIndex = val.indexOf(",", commaIndex + 1);
+          }
+        }
         return val.split(",");
       }
       if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
@@ -1568,10 +1631,7 @@ var require_parse = __commonJS({
           val = isArray(val) ? [val] : val;
         }
         if (options.comma && isArray(val) && val.length > options.arrayLimit) {
-          if (options.throwOnLimitExceeded) {
-            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
-          }
-          val = utils.combine([], val, options.arrayLimit, options.plainObjects);
+          val = utils.combine([], val, options.arrayLimit, options.plainObjects, options.throwOnLimitExceeded);
         }
         if (key !== null) {
           var existing = has.call(obj, key);
@@ -1580,7 +1640,8 @@ var require_parse = __commonJS({
               obj[key],
               val,
               options.arrayLimit,
-              options.plainObjects
+              options.plainObjects,
+              options.throwOnLimitExceeded
             );
           } else if (!existing || options.duplicates === "last") {
             obj[key] = val;
@@ -1607,7 +1668,8 @@ var require_parse = __commonJS({
               [],
               leaf,
               options.arrayLimit,
-              options.plainObjects
+              options.plainObjects,
+              options.throwOnLimitExceeded
             );
           }
         } else {

package/chunks/{chunk-DJECZIJX.js → chunk-ZTPGUFQV.js}

@@ -5,7 +5,7 @@ import {
   relaxSchemaForFunctionCalling,
   safeJsonParse,
   setGenAiUsageProvenance
-} from "./chunk-ABS25QER.js";
+} from "./chunk-ANVG3BVV.js";
 import {
   createOpenAIReasoningThoughtPart
 } from "./chunk-PQEISIKS.js";
@@ -17,17 +17,17 @@ import {
   TOKEN_ESTIMATE_UNITS_PER_TOKEN,
   estimateTextTokenUnits,
   estimateTextTokens
-} from "./chunk-BKWNKLZB.js";
+} from "./chunk-DYTW3QVG.js";
 import {
   normalizeMcpToolName
 } from "./chunk-WZAD4ZNJ.js";
 import {
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   FinishReason,
   GenerateContentResponse
-} from "./chunk-64REQJJ2.js";
+} from "./chunk-5H5S4UY5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -71,6 +71,9 @@ var TaggedThinkingParser = class {
   }
   mode = "text";
   buffer = "";
+  hasUnclosedThought() {
+    return this.mode === "thought";
+  }
   parse(chunk, final = false) {
     this.buffer += chunk;
     const lower = this.buffer.toLowerCase();
@@ -766,7 +769,7 @@ function extractTextFromContentUnion(contentUnion) {
 }
 __name(extractTextFromContentUnion, "extractTextFromContentUnion");
 function convertOpenAITextToParts(text, requestContext, final = true) {
-  if (!requestContext.responseParsingOptions?.taggedThinkingTags) {
+  if (!requestContext.responseParsingOptions?.taggedThinkingTags && !requestContext.taggedThinkingParser) {
     return text ? [{ text }] : [];
   }
   if (requestContext.taggedThinkingParser) {
@@ -946,15 +949,31 @@ function convertOpenAIChunkToLlm(chunk, requestContext) {
     let contentParts = [];
     const reasoningText = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
     if (typeof choice.delta?.content === "string") {
-      const normalizedContent = normalizeStreamingTextDelta(
-        choice.delta.content,
+      const rawContent = choice.delta.content;
+      const replayState = requestContext.textDeltaState;
+      const replayedTaggedThinkingSnapshot = requestContext.responseParsingOptions?.taggedThinkingTagsAfterReasoning === true && requestContext.taggedThinkingParser !== void 0 && replayState !== void 0 && (replayState.emittedText === rawContent || rawContent.length === replayState.emittedLength && rawContent.startsWith(replayState.emittedText)) && THINKING_TAG_PATTERN.test(rawContent);
+      if (replayedTaggedThinkingSnapshot) {
+        replayState.emittedText = rawContent;
+        replayState.emittedLength = rawContent.length;
+        replayState.cumulativeMode = true;
+      }
+      const normalizedContent = replayedTaggedThinkingSnapshot ? "" : normalizeStreamingTextDelta(
+        rawContent,
         requestContext.textDeltaState ??= {
           emittedText: "",
           emittedLength: 0,
           cumulativeMode: false
         }
       );
-      if (normalizedContent || choice.finish_reason) {
+      const taggedThinkingCandidate = (requestContext.pendingThinkingTagCandidate?.text ?? "") + normalizedContent;
+      if (requestContext.responseParsingOptions?.taggedThinkingTagsAfterReasoning && (requestContext.hasStructuredReasoningContent || reasoningText) && LEADING_THINKING_TAG_PATTERN.test(taggedThinkingCandidate) && !taggedThinkingCandidate.trimStart().startsWith("</")) {
+        requestContext.taggedThinkingParser ??= new TaggedThinkingParser();
+        requestContext.pendingThinkingTagCandidate = void 0;
+        contentParts = requestContext.taggedThinkingParser.parse(
+          taggedThinkingCandidate,
+          Boolean(choice.finish_reason)
+        );
+      } else if (normalizedContent || choice.finish_reason) {
         contentParts = convertOpenAITextToParts(
           normalizedContent,
           requestContext,
@@ -964,6 +983,9 @@ function convertOpenAIChunkToLlm(chunk, requestContext) {
     } else if (choice.finish_reason) {
       contentParts = convertOpenAITextToParts("", requestContext, true);
     }
+    if (choice.finish_reason && requestContext.responseParsingOptions?.taggedThinkingTagsAfterReasoning && requestContext.taggedThinkingParser?.hasUnclosedThought()) {
+      throwProtocolTagLeak(requestContext);
+    }
     if (hasThoughtPart(contentParts)) {
       requestContext.hasTaggedThinkingThought = true;
       requestContext.pendingReasoningText = void 0;

package/chunks/{chunk-7EQQR46F.js → chunk-ZVP4PWBU.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   Storage
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";