ai 3.3.30 → 3.3.31

package/dist/index.mjs

@@ -1461,7 +1461,7 @@ var objectOutputStrategy = (schema) => ({
 var arrayOutputStrategy = (schema) => {
   const { $schema, ...itemSchema } = schema.jsonSchema;
   return {
-    type: "array",
+    type: "enum",
     // wrap in object that contains array of elements, since most LLMs will not
     // be able to generate an array directly:
     // possible future optimization: use arrays directly when model supports grammar-guided generation
@@ -1565,15 +1565,64 @@ var arrayOutputStrategy = (schema) => {
     }
   };
 };
+var enumOutputStrategy = (enumValues) => {
+  return {
+    type: "enum",
+    // wrap in object that contains result, since most LLMs will not
+    // be able to generate an enum value directly:
+    // possible future optimization: use enums directly when model supports top-level enums
+    jsonSchema: {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      type: "object",
+      properties: {
+        result: { type: "string", enum: enumValues }
+      },
+      required: ["result"],
+      additionalProperties: false
+    },
+    validateFinalResult(value) {
+      if (!isJSONObject(value) || typeof value.result !== "string") {
+        return {
+          success: false,
+          error: new TypeValidationError({
+            value,
+            cause: 'value must be an object that contains a string in the "result" property.'
+          })
+        };
+      }
+      const result = value.result;
+      return enumValues.includes(result) ? { success: true, value: result } : {
+        success: false,
+        error: new TypeValidationError({
+          value,
+          cause: "value must be a string in the enum"
+        })
+      };
+    },
+    validatePartialResult() {
+      throw new UnsupportedFunctionalityError({
+        functionality: "partial results in enum mode"
+      });
+    },
+    createElementStream() {
+      throw new UnsupportedFunctionalityError({
+        functionality: "element streams in enum mode"
+      });
+    }
+  };
+};
 function getOutputStrategy({
   output,
-  schema
+  schema,
+  enumValues
 }) {
   switch (output) {
     case "object":
       return objectOutputStrategy(asSchema(schema));
     case "array":
       return arrayOutputStrategy(asSchema(schema));
+    case "enum":
+      return enumOutputStrategy(enumValues);
     case "no-schema":
       return noSchemaOutputStrategy;
     default: {
@@ -1589,9 +1638,10 @@ function validateObjectGenerationInput({
   mode,
   schema,
   schemaName,
-  schemaDescription
+  schemaDescription,
+  enumValues
 }) {
-  if (output != null && output !== "object" && output !== "array" && output !== "no-schema") {
+  if (output != null && output !== "object" && output !== "array" && output !== "enum" && output !== "no-schema") {
     throw new InvalidArgumentError({
       parameter: "output",
       value: output,
@@ -1627,6 +1677,13 @@ function validateObjectGenerationInput({
         message: "Schema name is not supported for no-schema output."
       });
     }
+    if (enumValues != null) {
+      throw new InvalidArgumentError({
+        parameter: "enumValues",
+        value: enumValues,
+        message: "Enum values are not supported for no-schema output."
+      });
+    }
   }
   if (output === "object") {
     if (schema == null) {
@@ -1636,6 +1693,13 @@ function validateObjectGenerationInput({
         message: "Schema is required for object output."
       });
     }
+    if (enumValues != null) {
+      throw new InvalidArgumentError({
+        parameter: "enumValues",
+        value: enumValues,
+        message: "Enum values are not supported for object output."
+      });
+    }
   }
   if (output === "array") {
     if (schema == null) {
@@ -1645,6 +1709,52 @@ function validateObjectGenerationInput({
         message: "Element schema is required for array output."
       });
     }
+    if (enumValues != null) {
+      throw new InvalidArgumentError({
+        parameter: "enumValues",
+        value: enumValues,
+        message: "Enum values are not supported for array output."
+      });
+    }
+  }
+  if (output === "enum") {
+    if (schema != null) {
+      throw new InvalidArgumentError({
+        parameter: "schema",
+        value: schema,
+        message: "Schema is not supported for enum output."
+      });
+    }
+    if (schemaDescription != null) {
+      throw new InvalidArgumentError({
+        parameter: "schemaDescription",
+        value: schemaDescription,
+        message: "Schema description is not supported for enum output."
+      });
+    }
+    if (schemaName != null) {
+      throw new InvalidArgumentError({
+        parameter: "schemaName",
+        value: schemaName,
+        message: "Schema name is not supported for enum output."
+      });
+    }
+    if (enumValues == null) {
+      throw new InvalidArgumentError({
+        parameter: "enumValues",
+        value: enumValues,
+        message: "Enum values are required for enum output."
+      });
+    }
+    for (const value of enumValues) {
+      if (typeof value !== "string") {
+        throw new InvalidArgumentError({
+          parameter: "enumValues",
+          value,
+          message: "Enum values must be strings."
+        });
+      }
+    }
   }
 }
 
@@ -1652,6 +1762,8 @@ function validateObjectGenerationInput({
 var originalGenerateId = createIdGenerator({ prefix: "aiobj-", length: 24 });
 async function generateObject({
   model,
+  enum: enumValues,
+  // rename bc enum is reserved by typescript
   schema: inputSchema,
   schemaName,
   schemaDescription,
@@ -1676,9 +1788,14 @@ async function generateObject({
     mode,
     schema: inputSchema,
     schemaName,
-    schemaDescription
+    schemaDescription,
+    enumValues
+  });
+  const outputStrategy = getOutputStrategy({
+    output,
+    schema: inputSchema,
+    enumValues
   });
-  const outputStrategy = getOutputStrategy({ output, schema: inputSchema });
   if (outputStrategy.type === "no-schema" && mode === void 0) {
     mode = "json";
   }