@ai-sdk-tool/parser 4.1.21 → 4.1.22

package/dist/community.cjs

@@ -2862,7 +2862,7 @@ function handleOpeningTagSegment(src, lt, out, stack) {
 function extractSchemaProperties(schema) {
   const unwrapped = unwrapJsonSchema(schema);
   if (!unwrapped || typeof unwrapped !== "object") {
-    return void 0;
+    return;
   }
   return unwrapped.properties;
 }
@@ -5061,10 +5061,10 @@ function findTopLevelPropertyValueStart(text, property) {
 function extractTopLevelStringProperty(text, property) {
   const valueStart = findTopLevelPropertyValueStart(text, property);
   if (valueStart == null || valueStart >= text.length) {
-    return void 0;
+    return;
   }
   if (text.charAt(valueStart) !== '"') {
-    return void 0;
+    return;
   }
   let valueEnd = valueStart + 1;
   let escaped = false;
@@ -5079,7 +5079,7 @@ function extractTopLevelStringProperty(text, property) {
     }
     valueEnd += 1;
   }
-  return void 0;
+  return;
 }
 function extractJsonValueSlice(text, valueStart) {
   if (valueStart >= text.length) {
@@ -5243,7 +5243,7 @@ function emitToolCallFromParsed(state, controller, parsedToolCall, tools) {
 }
 function canonicalizeArgumentsProgressInput(progress, toolName, tools) {
   if (progress.argumentsText === void 0 || !progress.argumentsComplete) {
-    return void 0;
+    return;
   }
   try {
     const parsedArguments = parse3(
@@ -5256,7 +5256,7 @@ function canonicalizeArgumentsProgressInput(progress, toolName, tools) {
       fallback: canonicalizeToolInput
     });
   } catch (e) {
-    return void 0;
+    return;
   }
 }
 function emitToolInputProgress(state, controller, tools) {
@@ -7969,7 +7969,7 @@ function parseQwen3CoderToolParserClosedMatches(inner, outerNameAttr) {
   var _a, _b;
   const callBlockMatches = Array.from(inner.matchAll(CALL_BLOCK_RE));
   if (callBlockMatches.length === 0) {
-    return void 0;
+    return;
   }
   const closedBlocks = [];
   let lastClosedEnd = 0;
@@ -8013,11 +8013,11 @@ function extractQwen3CoderToolNameFromMarkup(markup) {
   var _a, _b, _c, _d, _e;
   const match = markup.match(QWEN3CODER_TOOL_NAME_SALVAGE_REGEX);
   if (!match) {
-    return void 0;
+    return;
   }
   const name = (_e = (_d = (_c = (_b = (_a = match[1]) != null ? _a : match[2]) != null ? _b : match[3]) != null ? _c : match[4]) != null ? _d : match[5]) != null ? _e : match[6];
   if (!name) {
-    return void 0;
+    return;
   }
   const trimmed = name.trim();
   return trimmed.length > 0 ? trimmed : void 0;
@@ -8315,9 +8315,7 @@ var qwen3CoderProtocol = () => ({
       tryEmitToolCallSegment(synthetic, trailing);
       return true;
     };
-    const tryParseCallBlocksWithoutWrapper = () => {
-      return tryParseCallBlocksWithoutWrapperText(text);
-    };
+    const tryParseCallBlocksWithoutWrapper = () => tryParseCallBlocksWithoutWrapperText(text);
     const tryParseSingleFunctionCall = () => {
       const lowerText = text.toLowerCase();
       const startIndex = lowerText.indexOf("<function");
@@ -9461,7 +9459,14 @@ function processToolCallMatch(text, tc, currentIndex, processedElements, options
   }
   addTextSegment(text.slice(currentIndex, tc.startIndex), processedElements);
   const result = parseYamlContent(tc.content);
-  if (!result.ok) {
+  if (result.ok) {
+    processedElements.push({
+      type: "tool-call",
+      toolCallId: generateToolCallId(),
+      toolName: tc.toolName,
+      input: JSON.stringify(result.value)
+    });
+  } else {
     const originalText = text.slice(tc.startIndex, tc.endIndex);
     const cause = yamlFailureCause(result.failure);
     (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse YAML tool call", {
@@ -9472,13 +9477,6 @@ function processToolCallMatch(text, tc, currentIndex, processedElements, options
       cause
     });
     processedElements.push({ type: "text", text: originalText });
-  } else {
-    processedElements.push({
-      type: "tool-call",
-      toolCallId: generateToolCallId(),
-      toolName: tc.toolName,
-      input: JSON.stringify(result.value)
-    });
   }
   return tc.endIndex;
 }
@@ -9505,337 +9503,335 @@ function stripTrailingPartialCloseTag(content, toolName) {
   )}${preservedLeadingWhitespace}`;
   return contentWithoutPartial.trimEnd();
 }
-var yamlXmlProtocol = (_protocolOptions) => {
-  return {
-    formatTools({ tools, toolSystemPromptTemplate }) {
-      return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
-    },
-    formatToolCall(toolCall) {
-      let args = {};
-      if (toolCall.input != null) {
-        try {
-          args = JSON.parse(toolCall.input);
-        } catch (e) {
-          args = { value: toolCall.input };
-        }
+var yamlXmlProtocol = (_protocolOptions) => ({
+  formatTools({ tools, toolSystemPromptTemplate }) {
+    return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
+  },
+  formatToolCall(toolCall) {
+    let args = {};
+    if (toolCall.input != null) {
+      try {
+        args = JSON.parse(toolCall.input);
+      } catch (e) {
+        args = { value: toolCall.input };
       }
-      const yamlContent = import_yaml.default.stringify(args);
-      return `<${toolCall.toolName}>
+    }
+    const yamlContent = import_yaml.default.stringify(args);
+    return `<${toolCall.toolName}>
 ${yamlContent}</${toolCall.toolName}>`;
-    },
-    parseGeneratedText({ text, tools, options }) {
-      const toolNames = extractToolNames(tools);
-      if (toolNames.length === 0) {
-        return [{ type: "text", text }];
-      }
-      const processedElements = [];
-      let currentIndex = 0;
-      let parseText = text;
-      let toolCalls = findToolCalls2(parseText, toolNames);
-      if (toolCalls.length === 0) {
-        const repaired = tryRepairXmlSelfClosingRootWithBody(
-          parseText,
-          toolNames
-        );
-        if (repaired) {
-          const repairedCalls = findToolCalls2(repaired, toolNames);
-          if (repairedCalls.length > 0) {
-            parseText = repaired;
-            toolCalls = repairedCalls;
-          }
+  },
+  parseGeneratedText({ text, tools, options }) {
+    const toolNames = extractToolNames(tools);
+    if (toolNames.length === 0) {
+      return [{ type: "text", text }];
+    }
+    const processedElements = [];
+    let currentIndex = 0;
+    let parseText = text;
+    let toolCalls = findToolCalls2(parseText, toolNames);
+    if (toolCalls.length === 0) {
+      const repaired = tryRepairXmlSelfClosingRootWithBody(
+        parseText,
+        toolNames
+      );
+      if (repaired) {
+        const repairedCalls = findToolCalls2(repaired, toolNames);
+        if (repairedCalls.length > 0) {
+          parseText = repaired;
+          toolCalls = repairedCalls;
         }
       }
-      for (const tc of toolCalls) {
-        currentIndex = processToolCallMatch(
-          parseText,
-          tc,
-          currentIndex,
-          processedElements,
-          options
-        );
+    }
+    for (const tc of toolCalls) {
+      currentIndex = processToolCallMatch(
+        parseText,
+        tc,
+        currentIndex,
+        processedElements,
+        options
+      );
+    }
+    if (currentIndex < parseText.length) {
+      addTextSegment(parseText.slice(currentIndex), processedElements);
+    }
+    return processedElements;
+  },
+  createStreamParser({ tools, options }) {
+    const toolNames = extractToolNames(tools);
+    let buffer = "";
+    let currentToolCall = null;
+    let currentTextId = null;
+    let hasEmittedTextStart = false;
+    const flushText = createFlushTextHandler(
+      () => currentTextId,
+      (newId) => {
+        currentTextId = newId;
+      },
+      () => hasEmittedTextStart,
+      (value) => {
+        hasEmittedTextStart = value;
       }
-      if (currentIndex < parseText.length) {
-        addTextSegment(parseText.slice(currentIndex), processedElements);
+    );
+    const emitToolInputProgress2 = (controller, toolContent) => {
+      if (!currentToolCall) {
+        return;
       }
-      return processedElements;
-    },
-    createStreamParser({ tools, options }) {
-      const toolNames = extractToolNames(tools);
-      let buffer = "";
-      let currentToolCall = null;
-      let currentTextId = null;
-      let hasEmittedTextStart = false;
-      const flushText = createFlushTextHandler(
-        () => currentTextId,
-        (newId) => {
-          currentTextId = newId;
-        },
-        () => hasEmittedTextStart,
-        (value) => {
-          hasEmittedTextStart = value;
-        }
-      );
-      const emitToolInputProgress2 = (controller, toolContent) => {
-        if (!currentToolCall) {
-          return;
-        }
-        const parsedArgs = parseYamlContentForStreamProgress(toolContent);
-        if (parsedArgs === null) {
-          return;
-        }
-        const fullInput = stringifyToolInputWithSchema({
-          toolName: currentToolCall.name,
-          args: parsedArgs,
+      const parsedArgs = parseYamlContentForStreamProgress(toolContent);
+      if (parsedArgs === null) {
+        return;
+      }
+      const fullInput = stringifyToolInputWithSchema({
+        toolName: currentToolCall.name,
+        args: parsedArgs,
+        tools
+      });
+      if (fullInput === "{}" && toolContent.trim().length === 0) {
+        return;
+      }
+      emitToolInputProgressDelta({
+        controller,
+        id: currentToolCall.toolCallId,
+        state: currentToolCall,
+        fullInput
+      });
+    };
+    const processToolCallEnd = (controller, toolContent, toolName, toolCallId) => {
+      var _a;
+      const result = parseYamlContent(toolContent);
+      flushText(controller);
+      if (result.ok) {
+        const finalInput = stringifyToolInputWithSchema({
+          toolName,
+          args: result.value,
           tools
         });
-        if (fullInput === "{}" && toolContent.trim().length === 0) {
-          return;
-        }
-        emitToolInputProgressDelta({
-          controller,
-          id: currentToolCall.toolCallId,
-          state: currentToolCall,
-          fullInput
-        });
-      };
-      const processToolCallEnd = (controller, toolContent, toolName, toolCallId) => {
-        var _a;
-        const result = parseYamlContent(toolContent);
-        flushText(controller);
-        if (!result.ok) {
-          const original = `<${toolName}>${toolContent}</${toolName}>`;
-          const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
-          emitFailedToolInputLifecycle({
+        if (currentToolCall && currentToolCall.toolCallId === toolCallId) {
+          emitFinalizedToolInputLifecycle({
             controller,
             id: toolCallId,
-            emitRawToolCallTextOnError: emitRawFallback,
-            rawToolCallText: original,
-            emitRawText: (rawText) => {
-              flushText(controller, rawText);
-            }
-          });
-          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse streaming YAML tool call", {
-            toolCall: original,
-            toolName,
-            toolCallId,
-            dropReason: "malformed-tool-call-body",
-            cause: yamlFailureCause(result.failure)
-          });
-        } else {
-          const finalInput = stringifyToolInputWithSchema({
+            state: currentToolCall,
             toolName,
-            args: result.value,
-            tools
-          });
-          if (currentToolCall && currentToolCall.toolCallId === toolCallId) {
-            emitFinalizedToolInputLifecycle({
-              controller,
-              id: toolCallId,
-              state: currentToolCall,
-              toolName,
-              finalInput,
-              onMismatch: options == null ? void 0 : options.onError
-            });
-          } else {
-            enqueueToolInputEndAndCall({
-              controller,
-              id: toolCallId,
-              toolName,
-              input: finalInput
-            });
-          }
-        }
-      };
-      const finalizeUnclosedToolCall = (controller) => {
-        var _a;
-        if (!currentToolCall) {
-          return;
-        }
-        emitToolInputProgress2(controller, buffer);
-        const { name: toolName, toolCallId } = currentToolCall;
-        const reconciledBuffer = stripTrailingPartialCloseTag(buffer, toolName);
-        const result = parseYamlContent(reconciledBuffer);
-        flushText(controller);
-        if (!result.ok) {
-          const unfinishedContent = `<${toolName}>${buffer}`;
-          const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
-          emitFailedToolInputLifecycle({
-            controller,
-            id: toolCallId,
-            emitRawToolCallTextOnError: emitRawFallback,
-            rawToolCallText: unfinishedContent,
-            emitRawText: (rawText) => {
-              flushText(controller, rawText);
-            }
+            finalInput,
+            onMismatch: options == null ? void 0 : options.onError
           });
-          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
-            options,
-            "Could not complete streaming YAML tool call at finish.",
-            {
-              toolCall: unfinishedContent,
-              toolCallId,
-              toolName,
-              dropReason: "unfinished-tool-call",
-              cause: yamlFailureCause(result.failure)
-            }
-          );
         } else {
-          const finalInput = stringifyToolInputWithSchema({
-            toolName,
-            args: result.value,
-            tools
-          });
-          emitFinalizedToolInputLifecycle({
+          enqueueToolInputEndAndCall({
             controller,
             id: toolCallId,
-            state: currentToolCall,
             toolName,
-            finalInput,
-            onMismatch: options == null ? void 0 : options.onError
+            input: finalInput
           });
         }
-        buffer = "";
-        currentToolCall = null;
-      };
-      const handlePendingToolCall = (controller, endTag, toolName) => {
-        var _a;
-        const endIdx = buffer.indexOf(endTag);
-        if (endIdx === -1) {
-          emitToolInputProgress2(controller, buffer);
-          return false;
-        }
-        const content = buffer.slice(0, endIdx);
-        emitToolInputProgress2(controller, content);
-        buffer = buffer.slice(endIdx + endTag.length);
-        processToolCallEnd(
+      } else {
+        const original = `<${toolName}>${toolContent}</${toolName}>`;
+        const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
+        emitFailedToolInputLifecycle({
           controller,
-          content,
+          id: toolCallId,
+          emitRawToolCallTextOnError: emitRawFallback,
+          rawToolCallText: original,
+          emitRawText: (rawText) => {
+            flushText(controller, rawText);
+          }
+        });
+        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse streaming YAML tool call", {
+          toolCall: original,
           toolName,
-          (_a = currentToolCall == null ? void 0 : currentToolCall.toolCallId) != null ? _a : generateToolCallId()
+          toolCallId,
+          dropReason: "malformed-tool-call-body",
+          cause: yamlFailureCause(result.failure)
+        });
+      }
+    };
+    const finalizeUnclosedToolCall = (controller) => {
+      var _a;
+      if (!currentToolCall) {
+        return;
+      }
+      emitToolInputProgress2(controller, buffer);
+      const { name: toolName, toolCallId } = currentToolCall;
+      const reconciledBuffer = stripTrailingPartialCloseTag(buffer, toolName);
+      const result = parseYamlContent(reconciledBuffer);
+      flushText(controller);
+      if (result.ok) {
+        const finalInput = stringifyToolInputWithSchema({
+          toolName,
+          args: result.value,
+          tools
+        });
+        emitFinalizedToolInputLifecycle({
+          controller,
+          id: toolCallId,
+          state: currentToolCall,
+          toolName,
+          finalInput,
+          onMismatch: options == null ? void 0 : options.onError
+        });
+      } else {
+        const unfinishedContent = `<${toolName}>${buffer}`;
+        const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
+        emitFailedToolInputLifecycle({
+          controller,
+          id: toolCallId,
+          emitRawToolCallTextOnError: emitRawFallback,
+          rawToolCallText: unfinishedContent,
+          emitRawText: (rawText) => {
+            flushText(controller, rawText);
+          }
+        });
+        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+          options,
+          "Could not complete streaming YAML tool call at finish.",
+          {
+            toolCall: unfinishedContent,
+            toolCallId,
+            toolName,
+            dropReason: "unfinished-tool-call",
+            cause: yamlFailureCause(result.failure)
+          }
         );
+      }
+      buffer = "";
+      currentToolCall = null;
+    };
+    const handlePendingToolCall = (controller, endTag, toolName) => {
+      var _a;
+      const endIdx = buffer.indexOf(endTag);
+      if (endIdx === -1) {
+        emitToolInputProgress2(controller, buffer);
+        return false;
+      }
+      const content = buffer.slice(0, endIdx);
+      emitToolInputProgress2(controller, content);
+      buffer = buffer.slice(endIdx + endTag.length);
+      processToolCallEnd(
+        controller,
+        content,
+        toolName,
+        (_a = currentToolCall == null ? void 0 : currentToolCall.toolCallId) != null ? _a : generateToolCallId()
+      );
+      currentToolCall = null;
+      return true;
+    };
+    const flushSafeText = (controller) => {
+      const maxTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n} />`.length)) : 0;
+      const tail = Math.max(0, maxTagLen - 1);
+      const safeLen = Math.max(0, buffer.length - tail);
+      if (safeLen > 0) {
+        flushText(controller, buffer.slice(0, safeLen));
+        buffer = buffer.slice(safeLen);
+      }
+    };
+    const handleNewToolTag = (controller, tagIndex, tagName, selfClosing, tagLength) => {
+      if (tagIndex > 0) {
+        flushText(controller, buffer.slice(0, tagIndex));
+      }
+      flushText(controller);
+      if (selfClosing) {
+        buffer = buffer.slice(tagIndex + tagLength);
+        const toolCallId = generateToolCallId();
+        currentToolCall = {
+          name: tagName,
+          toolCallId,
+          emittedInput: ""
+        };
+        controller.enqueue({
+          type: "tool-input-start",
+          id: toolCallId,
+          toolName: tagName
+        });
+        processToolCallEnd(controller, "", tagName, toolCallId);
         currentToolCall = null;
-        return true;
-      };
-      const flushSafeText = (controller) => {
-        const maxTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n} />`.length)) : 0;
-        const tail = Math.max(0, maxTagLen - 1);
-        const safeLen = Math.max(0, buffer.length - tail);
-        if (safeLen > 0) {
-          flushText(controller, buffer.slice(0, safeLen));
-          buffer = buffer.slice(safeLen);
-        }
-      };
-      const handleNewToolTag = (controller, tagIndex, tagName, selfClosing, tagLength) => {
-        if (tagIndex > 0) {
-          flushText(controller, buffer.slice(0, tagIndex));
-        }
-        flushText(controller);
-        if (selfClosing) {
-          buffer = buffer.slice(tagIndex + tagLength);
-          const toolCallId = generateToolCallId();
-          currentToolCall = {
-            name: tagName,
-            toolCallId,
-            emittedInput: ""
-          };
-          controller.enqueue({
-            type: "tool-input-start",
-            id: toolCallId,
-            toolName: tagName
-          });
-          processToolCallEnd(controller, "", tagName, toolCallId);
-          currentToolCall = null;
+      } else {
+        const startTag = `<${tagName}>`;
+        buffer = buffer.slice(tagIndex + startTag.length);
+        currentToolCall = {
+          name: tagName,
+          toolCallId: generateToolCallId(),
+          emittedInput: ""
+        };
+        controller.enqueue({
+          type: "tool-input-start",
+          id: currentToolCall.toolCallId,
+          toolName: tagName
+        });
+      }
+    };
+    const processBuffer = (controller) => {
+      while (true) {
+        if (currentToolCall) {
+          const toolName = currentToolCall.name;
+          const endTag = `</${toolName}>`;
+          if (!handlePendingToolCall(controller, endTag, toolName)) {
+            break;
+          }
         } else {
-          const startTag = `<${tagName}>`;
-          buffer = buffer.slice(tagIndex + startTag.length);
-          currentToolCall = {
-            name: tagName,
-            toolCallId: generateToolCallId(),
-            emittedInput: ""
-          };
-          controller.enqueue({
-            type: "tool-input-start",
-            id: currentToolCall.toolCallId,
-            toolName: tagName
-          });
-        }
-      };
-      const processBuffer = (controller) => {
-        while (true) {
-          if (currentToolCall) {
-            const toolName = currentToolCall.name;
-            const endTag = `</${toolName}>`;
-            if (!handlePendingToolCall(controller, endTag, toolName)) {
-              break;
-            }
-          } else {
-            const { index, name, selfClosing, tagLength } = findEarliestToolTag(
-              buffer,
-              toolNames
-            );
-            if (index === -1) {
-              flushSafeText(controller);
-              break;
-            }
-            handleNewToolTag(controller, index, name, selfClosing, tagLength);
+          const { index, name, selfClosing, tagLength } = findEarliestToolTag(
+            buffer,
+            toolNames
+          );
+          if (index === -1) {
+            flushSafeText(controller);
+            break;
           }
+          handleNewToolTag(controller, index, name, selfClosing, tagLength);
         }
-      };
-      return new TransformStream({
-        transform(chunk, controller) {
-          var _a;
-          if (chunk.type === "finish") {
-            if (currentToolCall) {
-              finalizeUnclosedToolCall(controller);
-            } else if (buffer) {
-              flushText(controller, buffer);
-              buffer = "";
-            }
-            flushText(controller);
-            controller.enqueue(chunk);
-            return;
-          }
-          if (chunk.type !== "text-delta") {
-            if (!currentToolCall && buffer) {
-              flushText(controller, buffer);
-              buffer = "";
-            }
-            controller.enqueue(chunk);
-            return;
-          }
-          const textContent = (_a = chunk.delta) != null ? _a : "";
-          buffer += textContent;
-          processBuffer(controller);
-        },
-        flush(controller) {
+      }
+    };
+    return new TransformStream({
+      transform(chunk, controller) {
+        var _a;
+        if (chunk.type === "finish") {
           if (currentToolCall) {
             finalizeUnclosedToolCall(controller);
           } else if (buffer) {
             flushText(controller, buffer);
             buffer = "";
           }
-          if (currentTextId && hasEmittedTextStart) {
-            controller.enqueue({
-              type: "text-end",
-              id: currentTextId
-            });
-            hasEmittedTextStart = false;
-            currentTextId = null;
+          flushText(controller);
+          controller.enqueue(chunk);
+          return;
+        }
+        if (chunk.type !== "text-delta") {
+          if (!currentToolCall && buffer) {
+            flushText(controller, buffer);
+            buffer = "";
           }
+          controller.enqueue(chunk);
+          return;
+        }
+        const textContent = (_a = chunk.delta) != null ? _a : "";
+        buffer += textContent;
+        processBuffer(controller);
+      },
+      flush(controller) {
+        if (currentToolCall) {
+          finalizeUnclosedToolCall(controller);
+        } else if (buffer) {
+          flushText(controller, buffer);
+          buffer = "";
+        }
+        if (currentTextId && hasEmittedTextStart) {
+          controller.enqueue({
+            type: "text-end",
+            id: currentTextId
+          });
+          hasEmittedTextStart = false;
+          currentTextId = null;
         }
-      });
-    },
-    extractToolCallSegments({ text, tools }) {
-      const toolNames = tools.map((t) => t.name).filter(Boolean);
-      if (toolNames.length === 0) {
-        return [];
       }
-      return findToolCalls2(text, toolNames).map(
-        (tc) => `<${tc.toolName}>${tc.content}</${tc.toolName}>`
-      );
+    });
+  },
+  extractToolCallSegments({ text, tools }) {
+    const toolNames = tools.map((t) => t.name).filter(Boolean);
+    if (toolNames.length === 0) {
+      return [];
     }
-  };
-};
+    return findToolCalls2(text, toolNames).map(
+      (tc) => `<${tc.toolName}>${tc.content}</${tc.toolName}>`
+    );
+  }
+});
 
 // src/core/utils/dynamic-tool-schema.ts
 function createDynamicIfThenElseSchema(tools) {
@@ -10016,7 +10012,7 @@ function parseJsonCandidate(candidateText) {
   try {
     return parse3(candidateText);
   } catch (e) {
-    return void 0;
+    return;
   }
 }
 function extractCodeBlockCandidates(text) {