ai 6.0.0-beta.68 → 6.0.0-beta.70

package/dist/index.mjs

@@ -775,7 +775,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.0-beta.68" : "0.0.0-test";
+var VERSION = true ? "6.0.0-beta.70" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({ url }) => {
@@ -7219,13 +7219,13 @@ var DefaultEmbedResult = class {
 import { withUserAgentSuffix as withUserAgentSuffix4 } from "@ai-sdk/provider-utils";
 
 // src/util/split-array.ts
-function splitArray(array, chunkSize) {
+function splitArray(array2, chunkSize) {
   if (chunkSize <= 0) {
     throw new Error("chunkSize must be greater than 0");
   }
   const result = [];
-  for (let i = 0; i < array.length; i += chunkSize) {
-    result.push(array.slice(i, i + chunkSize));
+  for (let i = 0; i < array2.length; i += chunkSize) {
+    result.push(array2.slice(i, i + chunkSize));
   }
   return result;
 }
@@ -7747,9 +7747,9 @@ var arrayOutputStrategy = (schema) => {
             transform(chunk, controller) {
               switch (chunk.type) {
                 case "object": {
-                  const array = chunk.object;
-                  for (; publishedElements < array.length; publishedElements++) {
-                    controller.enqueue(array[publishedElements]);
+                  const array2 = chunk.object;
+                  for (; publishedElements < array2.length; publishedElements++) {
+                    controller.enqueue(array2[publishedElements]);
                   }
                   break;
                 }
@@ -9060,9 +9060,14 @@ var DefaultSpeechResult = class {
 // src/generate-text/output.ts
 var output_exports = {};
 __export(output_exports, {
+  array: () => array,
+  choice: () => choice,
   object: () => object,
   text: () => text
 });
+import {
+  TypeValidationError as TypeValidationError5
+} from "@ai-sdk/provider";
 import {
   asSchema as asSchema4,
   resolve,
@@ -9072,11 +9077,11 @@ import {
 var text = () => ({
   type: "text",
   responseFormat: Promise.resolve({ type: "text" }),
-  async parsePartial({ text: text2 }) {
-    return { partial: text2 };
-  },
   async parseOutput({ text: text2 }) {
     return text2;
+  },
+  async parsePartial({ text: text2 }) {
+    return { partial: text2 };
   }
 });
 var object = ({
@@ -9089,24 +9094,174 @@ var object = ({
       type: "json",
       schema: jsonSchema3
     })),
+    async parseOutput({ text: text2 }, context) {
+      const parseResult = await safeParseJSON4({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context.response,
+          usage: context.usage,
+          finishReason: context.finishReason
+        });
+      }
+      const validationResult = await safeValidateTypes4({
+        value: parseResult.value,
+        schema
+      });
+      if (!validationResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: validationResult.error,
+          text: text2,
+          response: context.response,
+          usage: context.usage,
+          finishReason: context.finishReason
+        });
+      }
+      return validationResult.value;
+    },
     async parsePartial({ text: text2 }) {
       const result = await parsePartialJson(text2);
       switch (result.state) {
         case "failed-parse":
-        case "undefined-input":
+        case "undefined-input": {
           return void 0;
+        }
         case "repaired-parse":
-        case "successful-parse":
+        case "successful-parse": {
           return {
             // Note: currently no validation of partial results:
             partial: result.value
           };
+        }
         default: {
           const _exhaustiveCheck = result.state;
           throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`);
         }
       }
+    }
+  };
+};
+var array = ({
+  element: inputElementSchema
+}) => {
+  const elementSchema = asSchema4(inputElementSchema);
+  return {
+    type: "object",
+    // JSON schema that describes an array of elements:
+    responseFormat: resolve(elementSchema.jsonSchema).then((jsonSchema3) => {
+      const { $schema, ...itemSchema } = jsonSchema3;
+      return {
+        type: "json",
+        schema: {
+          $schema: "http://json-schema.org/draft-07/schema#",
+          type: "object",
+          properties: {
+            elements: { type: "array", items: itemSchema }
+          },
+          required: ["elements"],
+          additionalProperties: false
+        }
+      };
+    }),
+    async parseOutput({ text: text2 }, context) {
+      const parseResult = await safeParseJSON4({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context.response,
+          usage: context.usage,
+          finishReason: context.finishReason
+        });
+      }
+      const outerValue = parseResult.value;
+      if (outerValue == null || typeof outerValue !== "object" || !("elements" in outerValue) || !Array.isArray(outerValue.elements)) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: new TypeValidationError5({
+            value: outerValue,
+            cause: "response must be an object with an elements array"
+          }),
+          text: text2,
+          response: context.response,
+          usage: context.usage,
+          finishReason: context.finishReason
+        });
+      }
+      for (const element of outerValue.elements) {
+        const validationResult = await safeValidateTypes4({
+          value: element,
+          schema: elementSchema
+        });
+        if (!validationResult.success) {
+          throw new NoObjectGeneratedError({
+            message: "No object generated: response did not match schema.",
+            cause: validationResult.error,
+            text: text2,
+            response: context.response,
+            usage: context.usage,
+            finishReason: context.finishReason
+          });
+        }
+      }
+      return outerValue.elements;
     },
+    async parsePartial({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return void 0;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          const outerValue = result.value;
+          if (outerValue == null || typeof outerValue !== "object" || !("elements" in outerValue) || !Array.isArray(outerValue.elements)) {
+            return void 0;
+          }
+          const rawElements = result.state === "repaired-parse" && outerValue.elements.length > 0 ? outerValue.elements.slice(0, -1) : outerValue.elements;
+          const parsedElements = [];
+          for (const rawElement of rawElements) {
+            const validationResult = await safeValidateTypes4({
+              value: rawElement,
+              schema: elementSchema
+            });
+            if (validationResult.success) {
+              parsedElements.push(validationResult.value);
+            }
+          }
+          return { partial: parsedElements };
+        }
+        default: {
+          const _exhaustiveCheck = result.state;
+          throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`);
+        }
+      }
+    }
+  };
+};
+var choice = ({
+  options: choiceOptions
+}) => {
+  return {
+    type: "object",
+    // JSON schema that describes an enumeration:
+    responseFormat: Promise.resolve({
+      type: "json",
+      schema: {
+        $schema: "http://json-schema.org/draft-07/schema#",
+        type: "object",
+        properties: {
+          result: { type: "string", enum: choiceOptions }
+        },
+        required: ["result"],
+        additionalProperties: false
+      }
+    }),
     async parseOutput({ text: text2 }, context) {
       const parseResult = await safeParseJSON4({ text: text2 });
       if (!parseResult.success) {
@@ -9119,21 +9274,49 @@ var object = ({
           finishReason: context.finishReason
         });
       }
-      const validationResult = await safeValidateTypes4({
-        value: parseResult.value,
-        schema
-      });
-      if (!validationResult.success) {
+      const outerValue = parseResult.value;
+      if (outerValue == null || typeof outerValue !== "object" || !("result" in outerValue) || typeof outerValue.result !== "string" || !choiceOptions.includes(outerValue.result)) {
         throw new NoObjectGeneratedError({
           message: "No object generated: response did not match schema.",
-          cause: validationResult.error,
+          cause: new TypeValidationError5({
+            value: outerValue,
+            cause: "response must be an object that contains a choice value."
+          }),
           text: text2,
           response: context.response,
           usage: context.usage,
           finishReason: context.finishReason
         });
       }
-      return validationResult.value;
+      return outerValue.result;
+    },
+    async parsePartial({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return void 0;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          const outerValue = result.value;
+          if (outerValue == null || typeof outerValue !== "object" || !("result" in outerValue) || typeof outerValue.result !== "string") {
+            return void 0;
+          }
+          const potentialMatches = choiceOptions.filter(
+            (choiceOption) => choiceOption.startsWith(outerValue.result)
+          );
+          if (result.state === "successful-parse") {
+            return potentialMatches.includes(outerValue.result) ? { partial: outerValue.result } : void 0;
+          } else {
+            return potentialMatches.length === 1 ? { partial: potentialMatches[0] } : void 0;
+          }
+        }
+        default: {
+          const _exhaustiveCheck = result.state;
+          throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`);
+        }
+      }
     }
   };
 };