ai 6.0.25 → 6.0.26

package/dist/index.mjs

@@ -921,7 +921,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.25" : "0.0.0-test";
+var VERSION = true ? "6.0.26" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({ url }) => {
@@ -10384,6 +10384,130 @@ function defaultSettingsMiddleware({
   };
 }
 
+// src/middleware/extract-json-middleware.ts
+function defaultTransform(text2) {
+  return text2.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
+}
+function extractJsonMiddleware(options) {
+  var _a16;
+  const transform = (_a16 = options == null ? void 0 : options.transform) != null ? _a16 : defaultTransform;
+  const hasCustomTransform = (options == null ? void 0 : options.transform) !== void 0;
+  return {
+    specificationVersion: "v3",
+    wrapGenerate: async ({ doGenerate }) => {
+      const { content, ...rest } = await doGenerate();
+      const transformedContent = [];
+      for (const part of content) {
+        if (part.type !== "text") {
+          transformedContent.push(part);
+          continue;
+        }
+        transformedContent.push({
+          ...part,
+          text: transform(part.text)
+        });
+      }
+      return { content: transformedContent, ...rest };
+    },
+    wrapStream: async ({ doStream }) => {
+      const { stream, ...rest } = await doStream();
+      const textBlocks = {};
+      const SUFFIX_BUFFER_SIZE = 12;
+      return {
+        stream: stream.pipeThrough(
+          new TransformStream({
+            transform: (chunk, controller) => {
+              if (chunk.type === "text-start") {
+                textBlocks[chunk.id] = {
+                  startEvent: chunk,
+                  // Custom transforms need to buffer all content
+                  phase: hasCustomTransform ? "buffering" : "prefix",
+                  buffer: "",
+                  prefixStripped: false
+                };
+                return;
+              }
+              if (chunk.type === "text-delta") {
+                const block = textBlocks[chunk.id];
+                if (!block) {
+                  controller.enqueue(chunk);
+                  return;
+                }
+                block.buffer += chunk.delta;
+                if (block.phase === "buffering") {
+                  return;
+                }
+                if (block.phase === "prefix") {
+                  if (block.buffer.length > 0 && !block.buffer.startsWith("`")) {
+                    block.phase = "streaming";
+                    controller.enqueue(block.startEvent);
+                  } else if (block.buffer.startsWith("```")) {
+                    if (block.buffer.includes("\n")) {
+                      const prefixMatch = block.buffer.match(/^```(?:json)?\s*\n/);
+                      if (prefixMatch) {
+                        block.buffer = block.buffer.slice(
+                          prefixMatch[0].length
+                        );
+                        block.prefixStripped = true;
+                        block.phase = "streaming";
+                        controller.enqueue(block.startEvent);
+                      } else {
+                        block.phase = "streaming";
+                        controller.enqueue(block.startEvent);
+                      }
+                    }
+                  } else if (block.buffer.length >= 3 && !block.buffer.startsWith("```")) {
+                    block.phase = "streaming";
+                    controller.enqueue(block.startEvent);
+                  }
+                }
+                if (block.phase === "streaming" && block.buffer.length > SUFFIX_BUFFER_SIZE) {
+                  const toStream = block.buffer.slice(0, -SUFFIX_BUFFER_SIZE);
+                  block.buffer = block.buffer.slice(-SUFFIX_BUFFER_SIZE);
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: chunk.id,
+                    delta: toStream
+                  });
+                }
+                return;
+              }
+              if (chunk.type === "text-end") {
+                const block = textBlocks[chunk.id];
+                if (block) {
+                  if (block.phase === "prefix" || block.phase === "buffering") {
+                    controller.enqueue(block.startEvent);
+                  }
+                  let remaining = block.buffer;
+                  if (block.phase === "buffering") {
+                    remaining = transform(remaining);
+                  } else if (block.prefixStripped) {
+                    remaining = remaining.replace(/\n?```\s*$/, "").trimEnd();
+                  } else {
+                    remaining = transform(remaining);
+                  }
+                  if (remaining.length > 0) {
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: chunk.id,
+                      delta: remaining
+                    });
+                  }
+                  controller.enqueue(chunk);
+                  delete textBlocks[chunk.id];
+                  return;
+                }
+              }
+              controller.enqueue(chunk);
+            }
+          })
+        ),
+        ...rest
+      };
+    }
+  };
+}
+
 // src/util/get-potential-start-index.ts
 function getPotentialStartIndex(text2, searchedText) {
   if (searchedText.length === 0) {
@@ -12185,6 +12309,7 @@ export {
   experimental_generateImage,
   generateSpeech as experimental_generateSpeech,
   transcribe as experimental_transcribe,
+  extractJsonMiddleware,
   extractReasoningMiddleware,
   gateway2 as gateway,
   generateId,