@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260718.767a32484

package/chunks/{chunk-V7EQTZYR.js → chunk-OCQ2QTFJ.js}

@@ -3,13 +3,15 @@
 import {
   InvalidStreamError,
   OpenAIContentConverter,
+  ProtocolTagSanitizedEvent,
   TaggedThinkingParser,
   getRateLimitErrorDetails,
+  logProtocolTagSanitized,
   openaiRequestCaptureContext
-} from "./chunk-P6LART6G.js";
+} from "./chunk-66IT3EY2.js";
 import {
   RequestTokenizer
-} from "./chunk-GDQQRV43.js";
+} from "./chunk-V2FRLYHN.js";
 import {
   DASHSCOPE_PROXY_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
@@ -17,33 +19,34 @@ 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-B7NUUEXC.js";
-import {
   runtimeDiagnostics,
-  safeJsonParse
-} from "./chunk-TQBODCFD.js";
+  safeJsonParse,
+  tokenLimit
+} from "./chunk-CMVFTMRD.js";
 import {
   GenerateContentResponse
-} from "./chunk-4LD5APFL.js";
+} from "./chunk-TYQMGACW.js";
 import {
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-LQIDP6K5.js";
+} from "./chunk-4CHDYDG3.js";
 import {
   createDebugLogger,
   getErrorStatus,
   getErrorType,
   isAbortError
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -7093,6 +7096,9 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
   constructor(contentGeneratorConfig, cliConfig) {
     super(contentGeneratorConfig, cliConfig);
   }
+  getResponseParsingOptions() {
+    return { contentOnlyThinkingTagLeaks: true };
+  }
   /**
    * Determines whether to use the DashScope-compatible provider.
    * Covers dashscope.aliyuncs.com, dashscope-intl.aliyuncs.com,
@@ -7792,8 +7798,12 @@ var StreamingToolCallParser = class {
   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
    *
@@ -7811,7 +7821,16 @@ var StreamingToolCallParser = class {
    * @returns ToolCallParseResult with completion status, parsed value, and repair info
    */
   addChunk(index, chunk, id, name) {
-    if (!id && !name && !chunk.trim()) {
+    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) {
@@ -7820,18 +7839,25 @@ var StreamingToolCallParser = class {
     }
     let actualIndex = index;
     const isKnownId = Boolean(id && this.idToIndexMap.has(id));
-    const isNameOnlyDelta = Boolean(name && chunk.length === 0);
+    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 {
@@ -7839,14 +7865,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 (!isNameOnlyDelta) {
-      if (this.buffers.has(index)) {
+      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()) {
@@ -7871,15 +7914,18 @@ 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 || name)) {
+    if (chunk.length === 0 && (id || validName)) {
       if (id) meta.id = id;
-      if (name && !meta.name) meta.name = name;
+      if (validName && !meta.name) meta.name = validName;
       if (!meta.name && meta.id) {
         this.namelessToolCallIndices.add(actualIndex);
       } else {
         this.namelessToolCallIndices.delete(actualIndex);
       }
-      return { complete: false };
+      if (!meta.id && actualIndex !== index) {
+        this.pendingIndexRemaps.set(index, actualIndex);
+      }
+      return { actualIndex, complete: false };
     }
     if (isKnownId && currentDepth === 0) {
       if (currentBuffer.trim()) {
@@ -7888,13 +7934,23 @@ var StreamingToolCallParser = class {
           debugLogger3.debug(
             `Ignoring replay chunk for completed toolCall id=${id}`
           );
-          return { complete: false };
+          return { actualIndex, complete: false };
         } catch {
         }
       }
     }
+    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;
@@ -7923,12 +7979,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
@@ -7937,12 +7994,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
@@ -7956,6 +8014,26 @@ var StreamingToolCallParser = class {
   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
    *
@@ -8088,6 +8166,11 @@ var StreamingToolCallParser = class {
     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
@@ -8104,7 +8187,10 @@ var StreamingToolCallParser = class {
     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
@@ -8405,7 +8491,8 @@ var ContentGenerationPipeline = class {
         const innerStream = this.processStreamWithLogging(
           guarded,
           context,
-          request
+          request,
+          userPromptId
         );
         async function* drainThenCleanup() {
           try {
@@ -8425,13 +8512,30 @@ var ContentGenerationPipeline = class {
    * 1. Convert OpenAI chunks to Gemini format while preserving original chunks
    * 2. Filter empty responses
    * 3. Handle chunk merging for providers that send finishReason and usageMetadata separately
-   * 4. Collect both formats for logging
-   * 5. Handle success/error logging
+   * 4. Handle success/error logging
    */
-  async *processStreamWithLogging(stream, context, request) {
-    const collectedGeminiResponses = [];
+  async *processStreamWithLogging(stream, context, request, userPromptId) {
     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") {
@@ -8442,9 +8546,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;
@@ -8452,26 +8569,57 @@ var ContentGenerationPipeline = class {
               pending.usageMetadata = response.usageMetadata;
             }
           }
-          collectedGeminiResponses.push(response);
           continue;
         }
+        if (!pendingFinishResponse && response.candidates?.[0]?.finishReason && sanitization) {
+          pendingFinishProtocolTagSanitized = sanitization;
+        }
         const shouldYield = this.handleChunkMerging(
           response,
-          collectedGeminiResponses,
+          pendingFinishResponse,
           (mergedResponse) => {
             pendingFinishResponse = mergedResponse;
           }
         );
         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) {
@@ -8481,6 +8629,14 @@ var ContentGenerationPipeline = class {
       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,
@@ -8500,43 +8656,37 @@ var ContentGenerationPipeline = class {
    * finishReason and the most up-to-date usage information from any provider pattern.
    *
    * @param response Current Gemini response
-   * @param collectedGeminiResponses Array to collect responses for logging
+   * @param pendingFinishResponse Finish response currently held for merging
    * @param setPendingFinish Callback to set pending finish response
    * @returns true if the response should be yielded, false if it should be held for merging
    */
-  handleChunkMerging(response, collectedGeminiResponses, setPendingFinish) {
+  handleChunkMerging(response, pendingFinishResponse, setPendingFinish) {
     const isFinishChunk = response.candidates?.[0]?.finishReason;
-    const hasPendingFinish = collectedGeminiResponses.length > 0 && collectedGeminiResponses[collectedGeminiResponses.length - 1].candidates?.[0]?.finishReason;
     if (isFinishChunk) {
-      if (hasPendingFinish) {
-        const lastResponse = collectedGeminiResponses[collectedGeminiResponses.length - 1];
+      if (pendingFinishResponse) {
         if (response.usageMetadata) {
-          lastResponse.usageMetadata = response.usageMetadata;
+          pendingFinishResponse.usageMetadata = response.usageMetadata;
         }
-        setPendingFinish(lastResponse);
+        setPendingFinish(pendingFinishResponse);
       } else {
-        collectedGeminiResponses.push(response);
         setPendingFinish(response);
       }
       return false;
-    } else if (hasPendingFinish) {
-      const lastResponse = collectedGeminiResponses[collectedGeminiResponses.length - 1];
+    } else if (pendingFinishResponse) {
       const mergedResponse = new GenerateContentResponse();
-      mergedResponse.candidates = lastResponse.candidates;
+      mergedResponse.candidates = pendingFinishResponse.candidates;
       if (response.usageMetadata) {
         mergedResponse.usageMetadata = response.usageMetadata;
       } else {
-        mergedResponse.usageMetadata = lastResponse.usageMetadata;
+        mergedResponse.usageMetadata = pendingFinishResponse.usageMetadata;
       }
       mergedResponse.responseId = response.responseId;
       mergedResponse.createTime = response.createTime;
       mergedResponse.modelVersion = response.modelVersion;
       mergedResponse.promptFeedback = response.promptFeedback;
-      collectedGeminiResponses[collectedGeminiResponses.length - 1] = mergedResponse;
       setPendingFinish(mergedResponse);
       return true;
     }
-    collectedGeminiResponses.push(response);
     return true;
   }
   async buildRequest(request, userPromptId, context, isStreaming) {
@@ -8560,6 +8710,12 @@ var ContentGenerationPipeline = class {
         request.config.tools,
         this.contentGeneratorConfig.schemaCompliance ?? "auto"
       );
+      const fcMode = request.config?.toolConfig?.functionCallingConfig?.mode;
+      if (fcMode === "ANY") {
+        baseRequest["tool_choice"] = "required";
+      } else if (fcMode === "NONE") {
+        baseRequest["tool_choice"] = "none";
+      }
     }
     const providerRequest = this.config.provider.buildRequest(
       baseRequest,