ai 3.1.0-canary.0 → 3.1.0-canary.2

package/core/dist/index.js

@@ -35,7 +35,6 @@ __export(core_exports, {
   StreamObjectResult: () => StreamObjectResult,
   StreamTextHttpResponse: () => StreamTextHttpResponse,
   StreamTextResult: () => StreamTextResult,
-  UnsupportedFunctionalityError: () => UnsupportedFunctionalityError,
   convertDataContentToBase64String: () => convertDataContentToBase64String,
   convertDataContentToUint8Array: () => convertDataContentToUint8Array,
   generateObject: () => generateObject,
@@ -46,7 +45,162 @@ __export(core_exports, {
 });
 module.exports = __toCommonJS(core_exports);
 
-// core/util/uint8-utils.ts
+// core/generate-object/generate-object.ts
+var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
+
+// ai-model-specification/errors/ai-invalid-argument-error.ts
+var AI_InvalidArgumentError = class extends Error {
+  // readonly learnMore =
+  //   'https://sdk.vercel.com/docs/ai/errors/ai_invalid_argument_error';
+  constructor({
+    parameter,
+    value,
+    message
+  }) {
+    super(`Invalid argument for parameter ${parameter}: ${message}`);
+    this.name = "AI_InvalidArgumentError";
+    this.parameter = parameter;
+    this.value = value;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+      parameter: this.parameter,
+      value: this.value
+    };
+  }
+};
+
+// ai-model-specification/util/get-error-message.ts
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
+
+// ai-model-specification/errors/json-parse-error.ts
+var JSONParseError = class extends Error {
+  constructor({ text, cause }) {
+    super(
+      `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`
+    );
+    this.name = "JSONParseError";
+    this.cause = cause;
+    this.text = text;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      cause: this.cause,
+      stack: this.stack,
+      valueText: this.text
+    };
+  }
+};
+
+// ai-model-specification/errors/no-object-generated-error.ts
+var NoTextGeneratedError = class extends Error {
+  constructor() {
+    super(`No text generated.`);
+    this.name = "NoTextGeneratedError";
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      cause: this.cause,
+      message: this.message,
+      stack: this.stack
+    };
+  }
+};
+
+// ai-model-specification/errors/type-validation-error.ts
+var TypeValidationError = class extends Error {
+  constructor({ value, cause }) {
+    super(
+      `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`
+    );
+    this.name = "TypeValidationError";
+    this.cause = cause;
+    this.value = value;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      cause: this.cause,
+      stack: this.stack,
+      value: this.value
+    };
+  }
+};
+
+// ai-model-specification/util/parse-json.ts
+var import_secure_json_parse = __toESM(require("secure-json-parse"));
+
+// ai-model-specification/util/validate-types.ts
+function safeValidateTypes({
+  value,
+  schema
+}) {
+  try {
+    const validationResult = schema.safeParse(value);
+    if (validationResult.success) {
+      return {
+        success: true,
+        value: validationResult.data
+      };
+    }
+    return {
+      success: false,
+      error: new TypeValidationError({
+        value,
+        cause: validationResult.error
+      })
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof TypeValidationError ? error : new TypeValidationError({ value, cause: error })
+    };
+  }
+}
+
+// ai-model-specification/util/parse-json.ts
+function safeParseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = import_secure_json_parse.default.parse(text);
+    if (schema == null) {
+      return {
+        success: true,
+        value
+      };
+    }
+    return safeValidateTypes({ value, schema });
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof JSONParseError ? error : new JSONParseError({ text, cause: error })
+    };
+  }
+}
+
+// ai-model-specification/util/uint8-utils.ts
 function convertBase64ToUint8Array(base64String) {
   const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
   const latin1string = globalThis.atob(base64Url);
@@ -171,129 +325,100 @@ function getInputFormat({
   return prompt != null ? "prompt" : "messages";
 }
 
-// core/schema/parse-json.ts
-var import_secure_json_parse = __toESM(require("secure-json-parse"));
-
-// core/language-model/errors/get-error-message.ts
-function getErrorMessage(error) {
-  if (error == null) {
-    return "unknown error";
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return JSON.stringify(error);
-}
-
-// core/language-model/errors/json-parse-error.ts
-var JSONParseError = class extends Error {
-  constructor({ text, cause }) {
-    super(
-      `JSON parsing failed: Text: ${text}.
-Error message: ${getErrorMessage(cause)}`
-    );
-    this.name = "JSONParseError";
-    this.cause = cause;
-    this.text = text;
+// core/prompt/validate-call-settings.ts
+function validateCallSettings(settings) {
+  if (settings.maxTokens != null) {
+    if (!Number.isInteger(settings.maxTokens)) {
+      throw new AI_InvalidArgumentError({
+        parameter: "maxTokens",
+        value: settings.maxTokens,
+        message: "maxTokens must be an integer"
+      });
+    }
+    if (settings.maxTokens < 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "maxTokens",
+        value: settings.maxTokens,
+        message: "maxTokens must be >= 1"
+      });
+    }
   }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      cause: this.cause,
-      stack: this.stack,
-      valueText: this.text
-    };
+  if (settings.temperature != null) {
+    if (typeof settings.temperature !== "number") {
+      throw new AI_InvalidArgumentError({
+        parameter: "temperature",
+        value: settings.temperature,
+        message: "temperature must be a number"
+      });
+    }
+    if (settings.temperature < 0 || settings.temperature > 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "temperature",
+        value: settings.temperature,
+        message: "temperature must be between 0 and 1 (inclusive)"
+      });
+    }
   }
-};
-
-// core/language-model/errors/type-validation-error.ts
-var TypeValidationError = class extends Error {
-  constructor({ value, cause }) {
-    super(
-      `Type validation failed: Value: ${JSON.stringify(value)}.
-Error message: ${getErrorMessage(cause)}`
-    );
-    this.name = "TypeValidationError";
-    this.cause = cause;
-    this.value = value;
+  if (settings.topP != null) {
+    if (typeof settings.topP !== "number") {
+      throw new AI_InvalidArgumentError({
+        parameter: "topP",
+        value: settings.topP,
+        message: "topP must be a number"
+      });
+    }
+    if (settings.topP < 0 || settings.topP > 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "topP",
+        value: settings.topP,
+        message: "topP must be between 0 and 1 (inclusive)"
+      });
+    }
   }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      cause: this.cause,
-      stack: this.stack,
-      value: this.value
-    };
+  if (settings.presencePenalty != null) {
+    if (typeof settings.presencePenalty !== "number") {
+      throw new AI_InvalidArgumentError({
+        parameter: "presencePenalty",
+        value: settings.presencePenalty,
+        message: "presencePenalty must be a number"
+      });
+    }
+    if (settings.presencePenalty < -1 || settings.presencePenalty > 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "presencePenalty",
+        value: settings.presencePenalty,
+        message: "presencePenalty must be between -1 and 1 (inclusive)"
+      });
+    }
   }
-};
-
-// core/schema/validate-types.ts
-function safeValidateTypes({
-  value,
-  schema
-}) {
-  try {
-    const validationResult = schema.validate(value);
-    if (validationResult.success) {
-      return validationResult;
+  if (settings.frequencyPenalty != null) {
+    if (typeof settings.frequencyPenalty !== "number") {
+      throw new AI_InvalidArgumentError({
+        parameter: "frequencyPenalty",
+        value: settings.frequencyPenalty,
+        message: "frequencyPenalty must be a number"
+      });
+    }
+    if (settings.frequencyPenalty < -1 || settings.frequencyPenalty > 1) {
+      throw new AI_InvalidArgumentError({
+        parameter: "frequencyPenalty",
+        value: settings.frequencyPenalty,
+        message: "frequencyPenalty must be between -1 and 1 (inclusive)"
+      });
     }
-    return {
-      success: false,
-      error: new TypeValidationError({
-        value,
-        cause: validationResult.error
-      })
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof TypeValidationError ? error : new TypeValidationError({ value, cause: error })
-    };
   }
-}
-
-// core/schema/parse-json.ts
-function safeParseJSON({
-  text,
-  schema
-}) {
-  try {
-    const value = import_secure_json_parse.default.parse(text);
-    if (schema == null) {
-      return {
-        success: true,
-        value
-      };
+  if (settings.seed != null) {
+    if (!Number.isInteger(settings.seed)) {
+      throw new AI_InvalidArgumentError({
+        parameter: "seed",
+        value: settings.seed,
+        message: "seed must be an integer"
+      });
     }
-    return safeValidateTypes({ value, schema });
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof JSONParseError ? error : new JSONParseError({ text, cause: error })
-    };
   }
+  return settings;
 }
 
-// core/schema/zod-schema.ts
-var import_zod_to_json_schema = require("zod-to-json-schema");
-var ZodSchema = class {
-  constructor(zodSchema) {
-    this.zodSchema = zodSchema;
-  }
-  validate(value) {
-    const result = this.zodSchema.safeParse(value);
-    return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-  }
-  getJsonSchema() {
-    return (0, import_zod_to_json_schema.zodToJsonSchema)(this.zodSchema);
-  }
-};
-
 // core/generate-object/inject-json-schema-into-system.ts
 var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
 var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
@@ -313,26 +438,10 @@ function injectJsonSchemaIntoSystem({
   ].filter((line) => line != null).join("\n");
 }
 
-// core/language-model/errors/no-object-generated-error.ts
-var NoTextGeneratedError = class extends Error {
-  constructor() {
-    super(`No text generated.`);
-    this.name = "NoTextGeneratedError";
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      cause: this.cause,
-      message: this.message,
-      stack: this.stack
-    };
-  }
-};
-
 // core/generate-object/generate-object.ts
 async function generateObject({
   model,
-  schema: zodSchema,
+  schema,
   mode,
   system,
   prompt,
@@ -340,15 +449,16 @@ async function generateObject({
   ...settings
 }) {
   var _a, _b;
-  const schema = new ZodSchema(zodSchema);
-  const jsonSchema = schema.getJsonSchema();
+  const jsonSchema = (0, import_zod_to_json_schema.default)(schema);
+  if (mode === "auto" || mode == null) {
+    mode = model.defaultObjectGenerationMode;
+  }
   let result;
-  mode = mode != null ? mode : model.defaultObjectGenerationMode;
   switch (mode) {
     case "json": {
       const generateResult = await model.doGenerate({
         mode: { type: "object-json" },
-        ...settings,
+        ...validateCallSettings(settings),
         inputFormat: getInputFormat({ prompt, messages }),
         prompt: convertToLanguageModelPrompt({
           system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
@@ -423,6 +533,9 @@ var GenerateObjectResult = class {
   }
 };
 
+// core/generate-object/stream-object.ts
+var import_zod_to_json_schema2 = __toESM(require("zod-to-json-schema"));
+
 // core/util/is-deep-equal-data.ts
 function isDeepEqualData(obj1, obj2) {
   if (obj1 === obj2)
@@ -798,22 +911,23 @@ function parsePartialJson(jsonText) {
 // core/generate-object/stream-object.ts
 async function streamObject({
   model,
-  schema: zodSchema,
+  schema,
   mode,
   system,
   prompt,
   messages,
   ...settings
 }) {
-  const schema = new ZodSchema(zodSchema);
-  const jsonSchema = schema.getJsonSchema();
+  const jsonSchema = (0, import_zod_to_json_schema2.default)(schema);
   let modelStream;
-  mode = mode != null ? mode : model.defaultObjectGenerationMode;
+  if (mode === "auto" || mode == null) {
+    mode = model.defaultObjectGenerationMode;
+  }
   switch (mode) {
     case "json": {
       const { stream, warnings } = await model.doStream({
         mode: { type: "object-json" },
-        ...settings,
+        ...validateCallSettings(settings),
         inputFormat: getInputFormat({ prompt, messages }),
         prompt: convertToLanguageModelPrompt({
           system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
@@ -938,7 +1052,7 @@ var StreamObjectResult = class {
 };
 
 // core/generate-text/generate-text.ts
-var import_zod_to_json_schema2 = __toESM(require("zod-to-json-schema"));
+var import_zod_to_json_schema3 = __toESM(require("zod-to-json-schema"));
 
 // core/generate-text/tool-call.ts
 function parseToolCall({
@@ -955,7 +1069,7 @@ function parseToolCall({
   }
   const parseResult = safeParseJSON({
     text: toolCall.args,
-    schema: new ZodSchema(tool2.parameters)
+    schema: tool2.parameters
   });
   if (parseResult.success === false) {
     throw new Error(
@@ -987,10 +1101,10 @@ async function generateText({
         type: "function",
         name,
         description: tool2.description,
-        parameters: (0, import_zod_to_json_schema2.default)(tool2.parameters)
+        parameters: (0, import_zod_to_json_schema3.default)(tool2.parameters)
       }))
     },
-    ...settings,
+    ...validateCallSettings(settings),
     inputFormat: getInputFormat({ prompt, messages }),
     prompt: convertToLanguageModelPrompt({
       system,
@@ -1044,7 +1158,7 @@ var GenerateTextResult = class {
 };
 
 // core/generate-text/stream-text.ts
-var import_zod_to_json_schema3 = __toESM(require("zod-to-json-schema"));
+var import_zod_to_json_schema4 = __toESM(require("zod-to-json-schema"));
 
 // core/generate-text/run-tools-transformation.ts
 var import_nanoid = require("nanoid");
@@ -1123,6 +1237,7 @@ function runToolsTransformation({
           }
           break;
         }
+        case "finish-metadata":
         case "tool-call-delta": {
           break;
         }
@@ -1412,10 +1527,10 @@ async function streamText({
         type: "function",
         name,
         description: tool2.description,
-        parameters: (0, import_zod_to_json_schema3.default)(tool2.parameters)
+        parameters: (0, import_zod_to_json_schema4.default)(tool2.parameters)
       }))
     },
-    ...settings,
+    ...validateCallSettings(settings),
     inputFormat: getInputFormat({ prompt, messages }),
     prompt: convertToLanguageModelPrompt({
       system,
@@ -1447,6 +1562,9 @@ var StreamTextResult = class {
                   return { value: value.textDelta, done: false };
                 }
               }
+              if (value.type === "error") {
+                console.error("Error:", value.error);
+              }
             }
           }
         };
@@ -1484,31 +1602,6 @@ var StreamTextResult = class {
 function tool(tool2) {
   return tool2;
 }
-
-// core/language-model/errors/unsupported-functionality-error.ts
-var UnsupportedFunctionalityError = class extends Error {
-  constructor({
-    provider,
-    functionality
-  }) {
-    super(
-      `Functionality not supported by the provider. Provider: ${provider}.
-Functionality: ${functionality}`
-    );
-    this.name = "UnsupportedFunctionalityError";
-    this.provider = provider;
-    this.functionality = functionality;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      provider: this.provider,
-      functionality: this.functionality
-    };
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GenerateObjectResult,
@@ -1516,7 +1609,6 @@ Functionality: ${functionality}`
   StreamObjectResult,
   StreamTextHttpResponse,
   StreamTextResult,
-  UnsupportedFunctionalityError,
   convertDataContentToBase64String,
   convertDataContentToUint8Array,
   generateObject,