ai 6.0.32 → 6.0.34

package/src/prompt/invalid-data-content-error.ts

@@ -0,0 +1,29 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_InvalidDataContentError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class InvalidDataContentError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly content: unknown;
+
+  constructor({
+    content,
+    cause,
+    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`,
+  }: {
+    content: unknown;
+    cause?: unknown;
+    message?: string;
+  }) {
+    super({ name, message, cause });
+
+    this.content = content;
+  }
+
+  static isInstance(error: unknown): error is InvalidDataContentError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/prompt/invalid-message-role-error.ts

@@ -0,0 +1,27 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_InvalidMessageRoleError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class InvalidMessageRoleError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly role: string;
+
+  constructor({
+    role,
+    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`,
+  }: {
+    role: string;
+    message?: string;
+  }) {
+    super({ name, message });
+
+    this.role = role;
+  }
+
+  static isInstance(error: unknown): error is InvalidMessageRoleError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/prompt/message-conversion-error.ts

@@ -0,0 +1,28 @@
+import { AISDKError } from '@ai-sdk/provider';
+import { UIMessage } from '../ui/ui-messages';
+
+const name = 'AI_MessageConversionError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class MessageConversionError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly originalMessage: Omit<UIMessage, 'id'>;
+
+  constructor({
+    originalMessage,
+    message,
+  }: {
+    originalMessage: Omit<UIMessage, 'id'>;
+    message: string;
+  }) {
+    super({ name, message });
+
+    this.originalMessage = originalMessage;
+  }
+
+  static isInstance(error: unknown): error is MessageConversionError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/prompt/message.ts

@@ -0,0 +1,68 @@
+import {
+  AssistantModelMessage,
+  ModelMessage,
+  SystemModelMessage,
+  ToolModelMessage,
+  UserModelMessage,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { providerMetadataSchema } from '../types/provider-metadata';
+import {
+  filePartSchema,
+  imagePartSchema,
+  reasoningPartSchema,
+  textPartSchema,
+  toolApprovalRequestSchema,
+  toolCallPartSchema,
+  toolApprovalResponseSchema,
+  toolResultPartSchema,
+} from './content-part';
+
+export const systemModelMessageSchema: z.ZodType<SystemModelMessage> = z.object(
+  {
+    role: z.literal('system'),
+    content: z.string(),
+    providerOptions: providerMetadataSchema.optional(),
+  },
+);
+
+export const userModelMessageSchema: z.ZodType<UserModelMessage> = z.object({
+  role: z.literal('user'),
+  content: z.union([
+    z.string(),
+    z.array(z.union([textPartSchema, imagePartSchema, filePartSchema])),
+  ]),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+export const assistantModelMessageSchema: z.ZodType<AssistantModelMessage> =
+  z.object({
+    role: z.literal('assistant'),
+    content: z.union([
+      z.string(),
+      z.array(
+        z.union([
+          textPartSchema,
+          filePartSchema,
+          reasoningPartSchema,
+          toolCallPartSchema,
+          toolResultPartSchema,
+          toolApprovalRequestSchema,
+        ]),
+      ),
+    ]),
+    providerOptions: providerMetadataSchema.optional(),
+  });
+
+export const toolModelMessageSchema: z.ZodType<ToolModelMessage> = z.object({
+  role: z.literal('tool'),
+  content: z.array(z.union([toolResultPartSchema, toolApprovalResponseSchema])),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+export const modelMessageSchema: z.ZodType<ModelMessage> = z.union([
+  systemModelMessageSchema,
+  userModelMessageSchema,
+  assistantModelMessageSchema,
+  toolModelMessageSchema,
+]);

package/src/prompt/prepare-call-settings.test.ts

@@ -0,0 +1,159 @@
+import { InvalidArgumentError } from '../error/invalid-argument-error';
+import { prepareCallSettings } from './prepare-call-settings';
+import { describe, it, expect } from 'vitest';
+
+describe('prepareCallSettings', () => {
+  describe('valid inputs', () => {
+    it('should not throw an error for valid settings', () => {
+      const validSettings = {
+        maxOutputTokens: 100,
+        temperature: 0.7,
+        topP: 0.9,
+        topK: 50,
+        presencePenalty: 0.5,
+        frequencyPenalty: 0.3,
+        seed: 42,
+        // stopSequences is not validated by validateCallSettings
+      };
+
+      expect(() => prepareCallSettings(validSettings)).not.toThrow();
+    });
+
+    it('should allow undefined values for optional settings', () => {
+      const validSettings = {
+        maxOutputTokens: undefined,
+        temperature: undefined,
+        topP: undefined,
+        topK: undefined,
+        presencePenalty: undefined,
+        frequencyPenalty: undefined,
+        seed: undefined,
+      };
+
+      expect(() => prepareCallSettings(validSettings)).not.toThrow();
+    });
+  });
+
+  describe('invalid inputs', () => {
+    describe('maxOutputTokens', () => {
+      it('should throw InvalidArgumentError if maxOutputTokens is not an integer', () => {
+        expect(() => prepareCallSettings({ maxOutputTokens: 10.5 })).toThrow(
+          new InvalidArgumentError({
+            parameter: 'maxOutputTokens',
+            value: 10.5,
+            message: 'maxOutputTokens must be an integer',
+          }),
+        );
+      });
+
+      it('should throw InvalidArgumentError if maxOutputTokens is less than 1', () => {
+        expect(() => prepareCallSettings({ maxOutputTokens: 0 })).toThrow(
+          new InvalidArgumentError({
+            parameter: 'maxOutputTokens',
+            value: 0,
+            message: 'maxOutputTokens must be >= 1',
+          }),
+        );
+      });
+    });
+
+    describe('temperature', () => {
+      it('should throw InvalidArgumentError if temperature is not a number', () => {
+        expect(() =>
+          prepareCallSettings({ temperature: 'invalid' as any }),
+        ).toThrow(
+          new InvalidArgumentError({
+            parameter: 'temperature',
+            value: 'invalid',
+            message: 'temperature must be a number',
+          }),
+        );
+      });
+    });
+
+    describe('topP', () => {
+      it('should throw InvalidArgumentError if topP is not a number', () => {
+        expect(() => prepareCallSettings({ topP: 'invalid' as any })).toThrow(
+          new InvalidArgumentError({
+            parameter: 'topP',
+            value: 'invalid',
+            message: 'topP must be a number',
+          }),
+        );
+      });
+    });
+
+    describe('topK', () => {
+      it('should throw InvalidArgumentError if topK is not a number', () => {
+        expect(() => prepareCallSettings({ topK: 'invalid' as any })).toThrow(
+          new InvalidArgumentError({
+            parameter: 'topK',
+            value: 'invalid',
+            message: 'topK must be a number',
+          }),
+        );
+      });
+    });
+
+    describe('presencePenalty', () => {
+      it('should throw InvalidArgumentError if presencePenalty is not a number', () => {
+        expect(() =>
+          prepareCallSettings({ presencePenalty: 'invalid' as any }),
+        ).toThrow(
+          new InvalidArgumentError({
+            parameter: 'presencePenalty',
+            value: 'invalid',
+            message: 'presencePenalty must be a number',
+          }),
+        );
+      });
+    });
+
+    describe('frequencyPenalty', () => {
+      it('should throw InvalidArgumentError if frequencyPenalty is not a number', () => {
+        expect(() =>
+          prepareCallSettings({ frequencyPenalty: 'invalid' as any }),
+        ).toThrow(
+          new InvalidArgumentError({
+            parameter: 'frequencyPenalty',
+            value: 'invalid',
+            message: 'frequencyPenalty must be a number',
+          }),
+        );
+      });
+    });
+
+    describe('seed', () => {
+      it('should throw InvalidArgumentError if seed is not an integer', () => {
+        expect(() => prepareCallSettings({ seed: 10.5 })).toThrow(
+          new InvalidArgumentError({
+            parameter: 'seed',
+            value: 10.5,
+            message: 'seed must be an integer',
+          }),
+        );
+      });
+    });
+  });
+
+  it('should return a new object with limited values', () => {
+    const settings = prepareCallSettings({
+      maxOutputTokens: 100,
+      temperature: 0.7,
+      random: 'invalid',
+    } as any);
+
+    expect(settings).toMatchInlineSnapshot(`
+      {
+        "frequencyPenalty": undefined,
+        "maxOutputTokens": 100,
+        "presencePenalty": undefined,
+        "seed": undefined,
+        "stopSequences": undefined,
+        "temperature": 0.7,
+        "topK": undefined,
+        "topP": undefined,
+      }
+    `);
+  });
+});

package/src/prompt/prepare-call-settings.ts

@@ -0,0 +1,108 @@
+import { InvalidArgumentError } from '../error/invalid-argument-error';
+import { CallSettings } from './call-settings';
+
+/**
+ * Validates call settings and returns a new object with limited values.
+ */
+export function prepareCallSettings({
+  maxOutputTokens,
+  temperature,
+  topP,
+  topK,
+  presencePenalty,
+  frequencyPenalty,
+  seed,
+  stopSequences,
+}: Omit<CallSettings, 'abortSignal' | 'headers' | 'maxRetries'>): Omit<
+  CallSettings,
+  'abortSignal' | 'headers' | 'maxRetries'
+> {
+  if (maxOutputTokens != null) {
+    if (!Number.isInteger(maxOutputTokens)) {
+      throw new InvalidArgumentError({
+        parameter: 'maxOutputTokens',
+        value: maxOutputTokens,
+        message: 'maxOutputTokens must be an integer',
+      });
+    }
+
+    if (maxOutputTokens < 1) {
+      throw new InvalidArgumentError({
+        parameter: 'maxOutputTokens',
+        value: maxOutputTokens,
+        message: 'maxOutputTokens must be >= 1',
+      });
+    }
+  }
+
+  if (temperature != null) {
+    if (typeof temperature !== 'number') {
+      throw new InvalidArgumentError({
+        parameter: 'temperature',
+        value: temperature,
+        message: 'temperature must be a number',
+      });
+    }
+  }
+
+  if (topP != null) {
+    if (typeof topP !== 'number') {
+      throw new InvalidArgumentError({
+        parameter: 'topP',
+        value: topP,
+        message: 'topP must be a number',
+      });
+    }
+  }
+
+  if (topK != null) {
+    if (typeof topK !== 'number') {
+      throw new InvalidArgumentError({
+        parameter: 'topK',
+        value: topK,
+        message: 'topK must be a number',
+      });
+    }
+  }
+
+  if (presencePenalty != null) {
+    if (typeof presencePenalty !== 'number') {
+      throw new InvalidArgumentError({
+        parameter: 'presencePenalty',
+        value: presencePenalty,
+        message: 'presencePenalty must be a number',
+      });
+    }
+  }
+
+  if (frequencyPenalty != null) {
+    if (typeof frequencyPenalty !== 'number') {
+      throw new InvalidArgumentError({
+        parameter: 'frequencyPenalty',
+        value: frequencyPenalty,
+        message: 'frequencyPenalty must be a number',
+      });
+    }
+  }
+
+  if (seed != null) {
+    if (!Number.isInteger(seed)) {
+      throw new InvalidArgumentError({
+        parameter: 'seed',
+        value: seed,
+        message: 'seed must be an integer',
+      });
+    }
+  }
+
+  return {
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    presencePenalty,
+    frequencyPenalty,
+    stopSequences,
+    seed,
+  };
+}