ai 3.2.0 → 3.2.1

package/dist/index.mjs

@@ -673,6 +673,13 @@ var GenerateObjectResult = class {
 };
 var experimental_generateObject = generateObject;
 
+// core/generate-object/stream-object.ts
+import { safeValidateTypes } from "@ai-sdk/provider-utils";
+import {
+  isDeepEqualData,
+  parsePartialJson
+} from "@ai-sdk/ui-utils";
+
 // core/util/async-iterable-stream.ts
 function createAsyncIterableStream(source, transformer) {
   const transformedStream = source.pipeThrough(
@@ -690,381 +697,17 @@ function createAsyncIterableStream(source, transformer) {
   return transformedStream;
 }
 
-// core/util/is-deep-equal-data.ts
-function isDeepEqualData(obj1, obj2) {
-  if (obj1 === obj2)
-    return true;
-  if (obj1 == null || obj2 == null)
-    return false;
-  if (typeof obj1 !== "object" && typeof obj2 !== "object")
-    return obj1 === obj2;
-  if (obj1.constructor !== obj2.constructor)
-    return false;
-  if (obj1 instanceof Date && obj2 instanceof Date) {
-    return obj1.getTime() === obj2.getTime();
-  }
-  if (Array.isArray(obj1)) {
-    if (obj1.length !== obj2.length)
-      return false;
-    for (let i = 0; i < obj1.length; i++) {
-      if (!isDeepEqualData(obj1[i], obj2[i]))
-        return false;
-    }
-    return true;
-  }
-  const keys1 = Object.keys(obj1);
-  const keys2 = Object.keys(obj2);
-  if (keys1.length !== keys2.length)
-    return false;
-  for (const key of keys1) {
-    if (!keys2.includes(key))
-      return false;
-    if (!isDeepEqualData(obj1[key], obj2[key]))
-      return false;
-  }
-  return true;
-}
-
-// core/util/parse-partial-json.ts
-import SecureJSON from "secure-json-parse";
-
-// core/util/fix-json.ts
-function fixJson(input) {
-  const stack = ["ROOT"];
-  let lastValidIndex = -1;
-  let literalStart = null;
-  function processValueStart(char, i, swapState) {
-    {
-      switch (char) {
-        case '"': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_STRING");
-          break;
-        }
-        case "f":
-        case "t":
-        case "n": {
-          lastValidIndex = i;
-          literalStart = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_LITERAL");
-          break;
-        }
-        case "-": {
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "0":
-        case "1":
-        case "2":
-        case "3":
-        case "4":
-        case "5":
-        case "6":
-        case "7":
-        case "8":
-        case "9": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "{": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_OBJECT_START");
-          break;
-        }
-        case "[": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_ARRAY_START");
-          break;
-        }
-      }
-    }
-  }
-  function processAfterObjectValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_OBJECT_AFTER_COMMA");
-        break;
-      }
-      case "}": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  function processAfterArrayValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_ARRAY_AFTER_COMMA");
-        break;
-      }
-      case "]": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    const currentState = stack[stack.length - 1];
-    switch (currentState) {
-      case "ROOT":
-        processValueStart(char, i, "FINISH");
-        break;
-      case "INSIDE_OBJECT_START": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-          case "}": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_COMMA": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_KEY": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_AFTER_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_KEY": {
-        switch (char) {
-          case ":": {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_BEFORE_VALUE": {
-        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        processAfterObjectValue(char, i);
-        break;
-      }
-      case "INSIDE_STRING": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            lastValidIndex = i;
-            break;
-          }
-          case "\\": {
-            stack.push("INSIDE_STRING_ESCAPE");
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_START": {
-        switch (char) {
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        switch (char) {
-          case ",": {
-            stack.pop();
-            stack.push("INSIDE_ARRAY_AFTER_COMMA");
-            break;
-          }
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_COMMA": {
-        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_STRING_ESCAPE": {
-        stack.pop();
-        lastValidIndex = i;
-        break;
-      }
-      case "INSIDE_NUMBER": {
-        switch (char) {
-          case "0":
-          case "1":
-          case "2":
-          case "3":
-          case "4":
-          case "5":
-          case "6":
-          case "7":
-          case "8":
-          case "9": {
-            lastValidIndex = i;
-            break;
-          }
-          case "e":
-          case "E":
-          case "-":
-          case ".": {
-            break;
-          }
-          case ",": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "}": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "]": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            break;
-          }
-          default: {
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, i + 1);
-        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
-          stack.pop();
-          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-            processAfterObjectValue(char, i);
-          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-            processAfterArrayValue(char, i);
-          }
-        } else {
-          lastValidIndex = i;
-        }
-        break;
-      }
-    }
-  }
-  let result = input.slice(0, lastValidIndex + 1);
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const state = stack[i];
-    switch (state) {
-      case "INSIDE_STRING": {
-        result += '"';
-        break;
-      }
-      case "INSIDE_OBJECT_KEY":
-      case "INSIDE_OBJECT_AFTER_KEY":
-      case "INSIDE_OBJECT_AFTER_COMMA":
-      case "INSIDE_OBJECT_START":
-      case "INSIDE_OBJECT_BEFORE_VALUE":
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        result += "}";
-        break;
-      }
-      case "INSIDE_ARRAY_START":
-      case "INSIDE_ARRAY_AFTER_COMMA":
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        result += "]";
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, input.length);
-        if ("true".startsWith(partialLiteral)) {
-          result += "true".slice(partialLiteral.length);
-        } else if ("false".startsWith(partialLiteral)) {
-          result += "false".slice(partialLiteral.length);
-        } else if ("null".startsWith(partialLiteral)) {
-          result += "null".slice(partialLiteral.length);
-        }
-      }
-    }
-  }
-  return result;
-}
-
-// core/util/parse-partial-json.ts
-function parsePartialJson(jsonText) {
-  if (jsonText == null) {
-    return void 0;
-  }
-  try {
-    return SecureJSON.parse(jsonText);
-  } catch (ignored) {
-    try {
-      const fixedJsonText = fixJson(jsonText);
-      return SecureJSON.parse(fixedJsonText);
-    } catch (ignored2) {
-    }
+// core/util/prepare-response-headers.ts
+function prepareResponseHeaders(init, { contentType }) {
+  var _a;
+  const headers = new Headers((_a = init == null ? void 0 : init.headers) != null ? _a : {});
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", contentType);
   }
-  return void 0;
+  return headers;
 }
 
 // core/generate-object/stream-object.ts
-import { safeValidateTypes } from "@ai-sdk/provider-utils";
 async function streamObject({
   model,
   schema,
@@ -1218,23 +861,39 @@ var StreamObjectResult = class {
     let object;
     let error;
     let accumulatedText = "";
+    let delta = "";
     let latestObject = void 0;
     this.originalStream = stream.pipeThrough(
       new TransformStream({
         async transform(chunk, controller) {
           if (typeof chunk === "string") {
             accumulatedText += chunk;
+            delta += chunk;
             const currentObject = parsePartialJson(
               accumulatedText
             );
             if (!isDeepEqualData(latestObject, currentObject)) {
               latestObject = currentObject;
-              controller.enqueue({ type: "object", object: currentObject });
+              controller.enqueue({
+                type: "object",
+                object: currentObject
+              });
+              controller.enqueue({
+                type: "text-delta",
+                textDelta: delta
+              });
+              delta = "";
             }
             return;
           }
           switch (chunk.type) {
             case "finish": {
+              if (delta !== "") {
+                controller.enqueue({
+                  type: "text-delta",
+                  textDelta: delta
+                });
+              }
               usage = calculateTokenUsage(chunk.usage);
               controller.enqueue({ ...chunk, usage });
               resolveUsage(usage);
@@ -1278,6 +937,12 @@ var StreamObjectResult = class {
       })
     );
   }
+  /**
+  Stream of partial objects. It gets more complete as the stream progresses.
+    
+  Note that the partial object is not validated. 
+  If you want to be certain that the actual content matches your schema, you need to implement your own validation for partial results.
+     */
   get partialObjectStream() {
     return createAsyncIterableStream(this.originalStream, {
       transform(chunk, controller) {
@@ -1285,6 +950,7 @@ var StreamObjectResult = class {
           case "object":
             controller.enqueue(chunk.object);
             break;
+          case "text-delta":
           case "finish":
             break;
           case "error":
@@ -1298,6 +964,34 @@ var StreamObjectResult = class {
       }
     });
   }
+  /**
+  Text stream of the JSON representation of the generated object. It contains text chunks. 
+  When the stream is finished, the object is valid JSON that can be parsed.
+     */
+  get textStream() {
+    return createAsyncIterableStream(this.originalStream, {
+      transform(chunk, controller) {
+        switch (chunk.type) {
+          case "text-delta":
+            controller.enqueue(chunk.textDelta);
+            break;
+          case "object":
+          case "finish":
+            break;
+          case "error":
+            controller.error(chunk.error);
+            break;
+          default: {
+            const _exhaustiveCheck = chunk;
+            throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
+          }
+        }
+      }
+    });
+  }
+  /**
+  Stream of different types of events, including partial objects, errors, and finish events.
+     */
   get fullStream() {
     return createAsyncIterableStream(this.originalStream, {
       transform(chunk, controller) {
@@ -1305,6 +999,53 @@ var StreamObjectResult = class {
       }
     });
   }
+  /**
+  Writes text delta output to a Node.js response-like object.
+  It sets a `Content-Type` header to `text/plain; charset=utf-8` and 
+  writes each text delta as a separate chunk.
+  
+  @param response A Node.js response-like object (ServerResponse).
+  @param init Optional headers and status code.
+     */
+  pipeTextStreamToResponse(response, init) {
+    var _a;
+    response.writeHead((_a = init == null ? void 0 : init.status) != null ? _a : 200, {
+      "Content-Type": "text/plain; charset=utf-8",
+      ...init == null ? void 0 : init.headers
+    });
+    const reader = this.textStream.pipeThrough(new TextEncoderStream()).getReader();
+    const read = async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          response.write(value);
+        }
+      } catch (error) {
+        throw error;
+      } finally {
+        response.end();
+      }
+    };
+    read();
+  }
+  /**
+  Creates a simple text stream response.
+  Each text delta is encoded as UTF-8 and sent as a separate chunk.
+  Non-text-delta events are ignored.
+  
+  @param init Optional headers and status code.
+     */
+  toTextStreamResponse(init) {
+    var _a;
+    return new Response(this.textStream.pipeThrough(new TextEncoderStream()), {
+      status: (_a = init == null ? void 0 : init.status) != null ? _a : 200,
+      headers: prepareResponseHeaders(init, {
+        contentType: "text/plain; charset=utf-8"
+      })
+    });
+  }
 };
 var experimental_streamObject = streamObject;
 
@@ -1509,16 +1250,6 @@ function toResponseMessages({
 }
 var experimental_generateText = generateText;
 
-// core/util/prepare-response-headers.ts
-function prepareResponseHeaders(init, { contentType }) {
-  var _a;
-  const headers = new Headers((_a = init == null ? void 0 : init.headers) != null ? _a : {});
-  if (!headers.has("Content-Type")) {
-    headers.set("Content-Type", contentType);
-  }
-  return headers;
-}
-
 // core/generate-text/run-tools-transformation.ts
 import { NoSuchToolError as NoSuchToolError2 } from "@ai-sdk/provider";
 import { generateId } from "@ai-sdk/ui-utils";