@fondation-io/ai 7.0.0-beta.45

package/src/prompt/index.ts

@@ -0,0 +1,27 @@
+export type { CallSettings, TimeoutConfiguration } from './call-settings';
+export {
+  assistantModelMessageSchema,
+  modelMessageSchema,
+  systemModelMessageSchema,
+  toolModelMessageSchema,
+  userModelMessageSchema,
+} from './message';
+export type { Prompt } from './prompt';
+
+// re-export types from provider-utils
+export type {
+  AssistantContent,
+  AssistantModelMessage,
+  DataContent,
+  FilePart,
+  ImagePart,
+  ModelMessage,
+  SystemModelMessage,
+  TextPart,
+  ToolCallPart,
+  ToolContent,
+  ToolModelMessage,
+  ToolResultPart,
+  UserContent,
+  UserModelMessage,
+} from '@ai-sdk/provider-utils';

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,72 @@
+import {
+  AssistantModelMessage,
+  ModelMessage,
+  SystemModelMessage,
+  ToolModelMessage,
+  UserModelMessage,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { providerMetadataSchema } from '../types/provider-metadata';
+import {
+  customPartSchema,
+  filePartSchema,
+  imagePartSchema,
+  reasoningFilePartSchema,
+  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,
+          customPartSchema,
+          filePartSchema,
+          reasoningPartSchema,
+          reasoningFilePartSchema,
+          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.ts

@@ -0,0 +1,110 @@
+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,
+  reasoning,
+}: 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,
+    reasoning,
+  };
+}

package/src/prompt/prepare-tools-and-tool-choice.ts

@@ -0,0 +1,86 @@
+import {
+  LanguageModelV4FunctionTool,
+  LanguageModelV4ProviderTool,
+  LanguageModelV4ToolChoice,
+} from '@ai-sdk/provider';
+import { asSchema } from '@ai-sdk/provider-utils';
+import { isNonEmptyObject } from '../util/is-non-empty-object';
+import { ToolSet } from '../generate-text';
+import { ToolChoice } from '../types/language-model';
+
+export async function prepareToolsAndToolChoice<TOOLS extends ToolSet>({
+  tools,
+  toolChoice,
+  activeTools,
+}: {
+  tools: TOOLS | undefined;
+  toolChoice: ToolChoice<TOOLS> | undefined;
+  activeTools: Array<keyof TOOLS> | undefined;
+}): Promise<{
+  tools:
+    | Array<LanguageModelV4FunctionTool | LanguageModelV4ProviderTool>
+    | undefined;
+  toolChoice: LanguageModelV4ToolChoice | undefined;
+}> {
+  if (!isNonEmptyObject(tools)) {
+    return {
+      tools: undefined,
+      toolChoice: undefined,
+    };
+  }
+
+  // when activeTools is provided, we only include the tools that are in the list:
+  const filteredTools =
+    activeTools != null
+      ? Object.entries(tools).filter(([name]) =>
+          activeTools.includes(name as keyof TOOLS),
+        )
+      : Object.entries(tools);
+
+  const languageModelTools: Array<
+    LanguageModelV4FunctionTool | LanguageModelV4ProviderTool
+  > = [];
+  for (const [name, tool] of filteredTools) {
+    const toolType = tool.type;
+
+    switch (toolType) {
+      case undefined:
+      case 'dynamic':
+      case 'function':
+        languageModelTools.push({
+          type: 'function' as const,
+          name,
+          description: tool.description,
+          inputSchema: await asSchema(tool.inputSchema).jsonSchema,
+          ...(tool.inputExamples != null
+            ? { inputExamples: tool.inputExamples }
+            : {}),
+          providerOptions: tool.providerOptions,
+          ...(tool.strict != null ? { strict: tool.strict } : {}),
+        });
+        break;
+      case 'provider':
+        languageModelTools.push({
+          type: 'provider' as const,
+          name,
+          id: tool.id,
+          args: tool.args,
+        });
+        break;
+      default: {
+        const exhaustiveCheck: never = toolType as never;
+        throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return {
+    tools: languageModelTools,
+    toolChoice:
+      toolChoice == null
+        ? { type: 'auto' }
+        : typeof toolChoice === 'string'
+          ? { type: toolChoice }
+          : { type: 'tool' as const, toolName: toolChoice.toolName as string },
+  };
+}

package/src/prompt/prompt.ts

@@ -0,0 +1,43 @@
+import { ModelMessage, SystemModelMessage } from '@ai-sdk/provider-utils';
+
+/**
+ * Prompt part of the AI function options.
+ * It contains a system message, a simple text prompt, or a list of messages.
+ */
+export type Prompt = {
+  /**
+   * System message to include in the prompt. Can be used with `prompt` or `messages`.
+   */
+  system?: string | SystemModelMessage | Array<SystemModelMessage>;
+} & (
+  | {
+      /**
+       * A prompt. It can be either a text prompt or a list of messages.
+       *
+       * You can either use `prompt` or `messages` but not both.
+       */
+      prompt: string | Array<ModelMessage>;
+
+      /**
+       * A list of messages.
+       *
+       * You can either use `prompt` or `messages` but not both.
+       */
+      messages?: never;
+    }
+  | {
+      /**
+       * A list of messages.
+       *
+       * You can either use `prompt` or `messages` but not both.
+       */
+      messages: Array<ModelMessage>;
+
+      /**
+       * A prompt. It can be either a text prompt or a list of messages.
+       *
+       * You can either use `prompt` or `messages` but not both.
+       */
+      prompt?: never;
+    }
+);

package/src/prompt/split-data-url.ts

@@ -0,0 +1,17 @@
+export function splitDataUrl(dataUrl: string): {
+  mediaType: string | undefined;
+  base64Content: string | undefined;
+} {
+  try {
+    const [header, base64Content] = dataUrl.split(',');
+    return {
+      mediaType: header.split(';')[0].split(':')[1],
+      base64Content,
+    };
+  } catch (error) {
+    return {
+      mediaType: undefined,
+      base64Content: undefined,
+    };
+  }
+}

package/src/prompt/standardize-prompt.ts

@@ -0,0 +1,99 @@
+import { InvalidPromptError } from '@ai-sdk/provider';
+import {
+  ModelMessage,
+  safeValidateTypes,
+  SystemModelMessage,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { modelMessageSchema } from './message';
+import { Prompt } from './prompt';
+import { asArray } from '../util/as-array';
+
+export type StandardizedPrompt = {
+  /**
+   * System message.
+   */
+  system?: string | SystemModelMessage | Array<SystemModelMessage>;
+
+  /**
+   * Messages.
+   */
+  messages: ModelMessage[];
+};
+
+export async function standardizePrompt(
+  prompt: Prompt,
+): Promise<StandardizedPrompt> {
+  if (prompt.prompt == null && prompt.messages == null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'prompt or messages must be defined',
+    });
+  }
+
+  if (prompt.prompt != null && prompt.messages != null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'prompt and messages cannot be defined at the same time',
+    });
+  }
+
+  // validate that system is a string or a SystemModelMessage
+  if (
+    prompt.system != null &&
+    typeof prompt.system !== 'string' &&
+    !asArray(prompt.system).every(
+      message =>
+        typeof message === 'object' &&
+        message !== null &&
+        'role' in message &&
+        message.role === 'system',
+    )
+  ) {
+    throw new InvalidPromptError({
+      prompt,
+      message:
+        'system must be a string, SystemModelMessage, or array of SystemModelMessage',
+    });
+  }
+
+  let messages: ModelMessage[];
+
+  if (prompt.prompt != null && typeof prompt.prompt === 'string') {
+    messages = [{ role: 'user', content: prompt.prompt }];
+  } else if (prompt.prompt != null && Array.isArray(prompt.prompt)) {
+    messages = prompt.prompt;
+  } else if (prompt.messages != null) {
+    messages = prompt.messages;
+  } else {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'prompt or messages must be defined',
+    });
+  }
+
+  if (messages.length === 0) {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'messages must not be empty',
+    });
+  }
+
+  const validationResult = await safeValidateTypes({
+    value: messages,
+    schema: z.array(modelMessageSchema),
+  });
+
+  if (!validationResult.success) {
+    throw new InvalidPromptError({
+      prompt,
+      message: 'The messages do not match the ModelMessage[] schema.',
+      cause: validationResult.error,
+    });
+  }
+
+  return {
+    messages,
+    system: prompt.system,
+  };
+}

package/src/prompt/wrap-gateway-error.ts

@@ -0,0 +1,29 @@
+import { GatewayAuthenticationError } from '@ai-sdk/gateway';
+import { AISDKError } from '@ai-sdk/provider';
+
+export function wrapGatewayError(error: unknown): unknown {
+  if (!GatewayAuthenticationError.isInstance(error)) return error;
+
+  const isProductionEnv = process?.env.NODE_ENV === 'production';
+  const moreInfoURL = 'https://ai-sdk.dev/unauthenticated-ai-gateway';
+
+  if (isProductionEnv) {
+    return new AISDKError({
+      name: 'GatewayError',
+      message: `Unauthenticated. Configure AI_GATEWAY_API_KEY or use a provider module. Learn more: ${moreInfoURL}`,
+    });
+  }
+
+  return Object.assign(
+    new Error(`\u001b[1m\u001b[31mUnauthenticated request to AI Gateway.\u001b[0m
+
+To authenticate, set the \u001b[33mAI_GATEWAY_API_KEY\u001b[0m environment variable with your API key.
+
+Alternatively, you can use a provider module instead of the AI Gateway.
+
+Learn more: \u001b[34m${moreInfoURL}\u001b[0m
+
+`),
+    { name: 'GatewayAuthenticationError' },
+  );
+}