@fondation-io/ai 7.0.0-beta.45

package/src/model/as-speech-model-v3.ts

@@ -0,0 +1,24 @@
+import { SpeechModelV2, SpeechModelV3 } from '@ai-sdk/provider';
+import { logV2CompatibilityWarning } from '../util/log-v2-compatibility-warning';
+
+export function asSpeechModelV3(
+  model: SpeechModelV3 | SpeechModelV2,
+): SpeechModelV3 {
+  if (model.specificationVersion === 'v3') {
+    return model;
+  }
+
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId,
+  });
+
+  // TODO this could break, we need to properly map v2 to v3
+  // and support all relevant v3 properties:
+  return new Proxy(model, {
+    get(target, prop: keyof SpeechModelV2) {
+      if (prop === 'specificationVersion') return 'v3';
+      return target[prop];
+    },
+  }) as unknown as SpeechModelV3;
+}

package/src/model/as-speech-model-v4.ts

@@ -0,0 +1,21 @@
+import { SpeechModelV2, SpeechModelV3, SpeechModelV4 } from '@ai-sdk/provider';
+import { asSpeechModelV3 } from './as-speech-model-v3';
+
+export function asSpeechModelV4(
+  model: SpeechModelV2 | SpeechModelV3 | SpeechModelV4,
+): SpeechModelV4 {
+  if (model.specificationVersion === 'v4') {
+    return model;
+  }
+
+  // first convert v2 to v3, then proxy v3 as v4:
+  const v3Model =
+    model.specificationVersion === 'v2' ? asSpeechModelV3(model) : model;
+
+  return new Proxy(v3Model, {
+    get(target, prop: keyof SpeechModelV3) {
+      if (prop === 'specificationVersion') return 'v4';
+      return target[prop];
+    },
+  }) as unknown as SpeechModelV4;
+}

package/src/model/as-transcription-model-v3.ts

@@ -0,0 +1,24 @@
+import { TranscriptionModelV2, TranscriptionModelV3 } from '@ai-sdk/provider';
+import { logV2CompatibilityWarning } from '../util/log-v2-compatibility-warning';
+
+export function asTranscriptionModelV3(
+  model: TranscriptionModelV3 | TranscriptionModelV2,
+): TranscriptionModelV3 {
+  if (model.specificationVersion === 'v3') {
+    return model;
+  }
+
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId,
+  });
+
+  // TODO this could break, we need to properly map v2 to v3
+  // and support all relevant v3 properties:
+  return new Proxy(model, {
+    get(target, prop: keyof TranscriptionModelV2) {
+      if (prop === 'specificationVersion') return 'v3';
+      return target[prop];
+    },
+  }) as unknown as TranscriptionModelV3;
+}

package/src/model/as-transcription-model-v4.ts

@@ -0,0 +1,25 @@
+import {
+  TranscriptionModelV2,
+  TranscriptionModelV3,
+  TranscriptionModelV4,
+} from '@ai-sdk/provider';
+import { asTranscriptionModelV3 } from './as-transcription-model-v3';
+
+export function asTranscriptionModelV4(
+  model: TranscriptionModelV2 | TranscriptionModelV3 | TranscriptionModelV4,
+): TranscriptionModelV4 {
+  if (model.specificationVersion === 'v4') {
+    return model;
+  }
+
+  // first convert v2 to v3, then proxy v3 as v4:
+  const v3Model =
+    model.specificationVersion === 'v2' ? asTranscriptionModelV3(model) : model;
+
+  return new Proxy(v3Model, {
+    get(target, prop: keyof TranscriptionModelV3) {
+      if (prop === 'specificationVersion') return 'v4';
+      return target[prop];
+    },
+  }) as unknown as TranscriptionModelV4;
+}

package/src/model/as-video-model-v4.ts

@@ -0,0 +1,19 @@
+import {
+  Experimental_VideoModelV3,
+  Experimental_VideoModelV4,
+} from '@ai-sdk/provider';
+
+export function asVideoModelV4(
+  model: Experimental_VideoModelV3 | Experimental_VideoModelV4,
+): Experimental_VideoModelV4 {
+  if (model.specificationVersion === 'v4') {
+    return model;
+  }
+
+  return new Proxy(model, {
+    get(target, prop: keyof Experimental_VideoModelV3) {
+      if (prop === 'specificationVersion') return 'v4';
+      return target[prop];
+    },
+  }) as unknown as Experimental_VideoModelV4;
+}

package/src/model/resolve-model.ts

@@ -0,0 +1,172 @@
+import { gateway } from '@ai-sdk/gateway';
+import {
+  EmbeddingModelV4,
+  Experimental_VideoModelV4,
+  ImageModelV4,
+  LanguageModelV4,
+  ProviderV4,
+  SpeechModelV4,
+  TranscriptionModelV4,
+} from '@ai-sdk/provider';
+import { UnsupportedModelVersionError } from '../error';
+import { EmbeddingModel } from '../types/embedding-model';
+import { LanguageModel } from '../types/language-model';
+import { SpeechModel } from '../types/speech-model';
+import { TranscriptionModel } from '../types/transcription-model';
+import { asEmbeddingModelV4 } from './as-embedding-model-v4';
+import { asImageModelV4 } from './as-image-model-v4';
+import { asLanguageModelV4 } from './as-language-model-v4';
+import { asSpeechModelV4 } from './as-speech-model-v4';
+import { asTranscriptionModelV4 } from './as-transcription-model-v4';
+import { asVideoModelV4 } from './as-video-model-v4';
+import { asProviderV4 } from './as-provider-v4';
+import { ImageModel } from '../types/image-model';
+import { VideoModel } from '../types/video-model';
+
+export function resolveLanguageModel(model: LanguageModel): LanguageModelV4 {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v4' &&
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+
+    return asLanguageModelV4(model);
+  }
+
+  return getGlobalProvider().languageModel(model);
+}
+
+export function resolveEmbeddingModel(model: EmbeddingModel): EmbeddingModelV4 {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v4' &&
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+
+    return asEmbeddingModelV4(model);
+  }
+
+  return getGlobalProvider().embeddingModel(model);
+}
+
+export function resolveTranscriptionModel(
+  model: TranscriptionModel,
+): TranscriptionModelV4 | undefined {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v4' &&
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+    return asTranscriptionModelV4(model);
+  }
+
+  return getGlobalProvider().transcriptionModel?.(model);
+}
+
+export function resolveSpeechModel(
+  model: SpeechModel,
+): SpeechModelV4 | undefined {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v4' &&
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+    return asSpeechModelV4(model);
+  }
+
+  return getGlobalProvider().speechModel?.(model);
+}
+
+export function resolveImageModel(model: ImageModel): ImageModelV4 {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v4' &&
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+
+    return asImageModelV4(model);
+  }
+
+  return getGlobalProvider().imageModel(model);
+}
+
+export function resolveVideoModel(
+  model: VideoModel,
+): Experimental_VideoModelV4 {
+  if (typeof model === 'string') {
+    // Use raw global provider because videoModel is experimental
+    // and not part of the ProviderV4 interface
+    const provider = globalThis.AI_SDK_DEFAULT_PROVIDER ?? gateway;
+    // TODO AI SDK v7
+    // @ts-expect-error - videoModel support is experimental
+    const videoModel = provider.videoModel;
+
+    if (!videoModel) {
+      throw new Error(
+        'The default provider does not support video models. ' +
+          'Please use a Experimental_VideoModelV4 object from a provider (e.g., vertex.video("model-id")).',
+      );
+    }
+
+    return videoModel(model);
+  }
+
+  if (
+    model.specificationVersion !== 'v4' &&
+    model.specificationVersion !== 'v3'
+  ) {
+    const unsupportedModel: any = model;
+    throw new UnsupportedModelVersionError({
+      version: unsupportedModel.specificationVersion,
+      provider: unsupportedModel.provider,
+      modelId: unsupportedModel.modelId,
+    });
+  }
+
+  return asVideoModelV4(model);
+}
+
+function getGlobalProvider(): ProviderV4 {
+  const provider = globalThis.AI_SDK_DEFAULT_PROVIDER ?? gateway;
+  return asProviderV4(provider);
+}

package/src/prompt/call-settings.ts

@@ -0,0 +1,169 @@
+import { LanguageModelV4CallOptions } from '@ai-sdk/provider';
+import type { ToolSet } from '../generate-text/tool-set';
+
+/**
+ * Timeout configuration for API calls. Can be specified as:
+ * - A number representing milliseconds
+ * - An object with `totalMs` property for the total timeout in milliseconds
+ * - An object with `stepMs` property for the timeout of each step in milliseconds
+ * - An object with `chunkMs` property for the timeout between stream chunks (streaming only)
+ */
+export type TimeoutConfiguration<TOOLS extends ToolSet> =
+  | number
+  | {
+      totalMs?: number;
+      stepMs?: number;
+      chunkMs?: number;
+      toolMs?: number;
+      tools?: Partial<Record<`${keyof TOOLS & string}Ms`, number>>;
+    };
+
+/**
+ * Extracts the total timeout value in milliseconds from a TimeoutConfiguration.
+ *
+ * @param timeout - The timeout configuration.
+ * @returns The total timeout in milliseconds, or undefined if no timeout is configured.
+ */
+export function getTotalTimeoutMs(
+  timeout: TimeoutConfiguration<any> | undefined,
+): number | undefined {
+  if (timeout == null) {
+    return undefined;
+  }
+  if (typeof timeout === 'number') {
+    return timeout;
+  }
+  return timeout.totalMs;
+}
+
+/**
+ * Extracts the step timeout value in milliseconds from a TimeoutConfiguration.
+ *
+ * @param timeout - The timeout configuration.
+ * @returns The step timeout in milliseconds, or undefined if no step timeout is configured.
+ */
+export function getStepTimeoutMs(
+  timeout: TimeoutConfiguration<any> | undefined,
+): number | undefined {
+  if (timeout == null || typeof timeout === 'number') {
+    return undefined;
+  }
+  return timeout.stepMs;
+}
+
+/**
+ * Extracts the chunk timeout value in milliseconds from a TimeoutConfiguration.
+ * This timeout is for streaming only - it aborts if no new chunk is received within the specified duration.
+ *
+ * @param timeout - The timeout configuration.
+ * @returns The chunk timeout in milliseconds, or undefined if no chunk timeout is configured.
+ */
+export function getChunkTimeoutMs(
+  timeout: TimeoutConfiguration<any> | undefined,
+): number | undefined {
+  if (timeout == null || typeof timeout === 'number') {
+    return undefined;
+  }
+  return timeout.chunkMs;
+}
+
+export function getToolTimeoutMs<TOOLS extends ToolSet>(
+  timeout: TimeoutConfiguration<TOOLS> | undefined,
+  toolName: keyof TOOLS & string,
+): number | undefined {
+  if (timeout == null || typeof timeout === 'number') {
+    return undefined;
+  }
+
+  return timeout.tools?.[`${toolName}Ms`] ?? timeout.toolMs;
+}
+
+export type CallSettings = {
+  /**
+   * Maximum number of tokens to generate.
+   */
+  maxOutputTokens?: number;
+
+  /**
+   * Temperature setting. The range depends on the provider and model.
+   *
+   * It is recommended to set either `temperature` or `topP`, but not both.
+   */
+  temperature?: number;
+
+  /**
+   * Nucleus sampling. This is a number between 0 and 1.
+   *
+   * E.g. 0.1 would mean that only tokens with the top 10% probability mass
+   * are considered.
+   *
+   * It is recommended to set either `temperature` or `topP`, but not both.
+   */
+  topP?: number;
+
+  /**
+   * Only sample from the top K options for each subsequent token.
+   *
+   * Used to remove "long tail" low probability responses.
+   * Recommended for advanced use cases only. You usually only need to use temperature.
+   */
+  topK?: number;
+
+  /**
+   * Presence penalty setting. It affects the likelihood of the model to
+   * repeat information that is already in the prompt.
+   *
+   * The presence penalty is a number between -1 (increase repetition)
+   * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+   */
+  presencePenalty?: number;
+
+  /**
+   * Frequency penalty setting. It affects the likelihood of the model
+   * to repeatedly use the same words or phrases.
+   *
+   * The frequency penalty is a number between -1 (increase repetition)
+   * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+   */
+  frequencyPenalty?: number;
+
+  /**
+   * Stop sequences.
+   * If set, the model will stop generating text when one of the stop sequences is generated.
+   * Providers may have limits on the number of stop sequences.
+   */
+  stopSequences?: string[];
+
+  /**
+   * The seed (integer) to use for random sampling. If set and supported
+   * by the model, calls will generate deterministic results.
+   */
+  seed?: number;
+
+  /**
+   * Reasoning effort level for the model. Controls how much reasoning
+   * the model performs before generating a response.
+   *
+   * Use `'provider-default'` to use the provider's default reasoning level.
+   * Use `'none'` to disable reasoning (if supported by the provider).
+   */
+  reasoning?: LanguageModelV4CallOptions['reasoning'];
+
+  /**
+   * Maximum number of retries. Set to 0 to disable retries.
+   *
+   * @default 2
+   */
+  maxRetries?: number;
+
+  /**
+   * Abort signal.
+   */
+  abortSignal?: AbortSignal;
+
+  /**
+   * Additional HTTP headers to be sent with the request.
+   * Only applicable for HTTP-based providers.
+   */
+  headers?: Record<string, string | undefined>;
+};

package/src/prompt/content-part.ts

@@ -0,0 +1,236 @@
+import {
+  CustomPart,
+  FilePart,
+  ImagePart,
+  ProviderOptions,
+  ReasoningFilePart,
+  ReasoningPart,
+  TextPart,
+  ToolApprovalRequest,
+  ToolApprovalResponse,
+  ToolResultOutput,
+  ToolResultPart,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { jsonValueSchema } from '../types/json-value';
+import { providerMetadataSchema } from '../types/provider-metadata';
+import { dataContentSchema } from './data-content';
+
+/**
+ * @internal
+ */
+export const textPartSchema: z.ZodType<TextPart> = z.object({
+  type: z.literal('text'),
+  text: z.string(),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * @internal
+ */
+export const imagePartSchema: z.ZodType<ImagePart> = z.object({
+  type: z.literal('image'),
+  image: z.union([dataContentSchema, z.instanceof(URL)]),
+  mediaType: z.string().optional(),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * @internal
+ */
+export const filePartSchema: z.ZodType<FilePart> = z.object({
+  type: z.literal('file'),
+  data: z.union([dataContentSchema, z.instanceof(URL)]),
+  filename: z.string().optional(),
+  mediaType: z.string(),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * @internal
+ */
+export const reasoningPartSchema: z.ZodType<ReasoningPart> = z.object({
+  type: z.literal('reasoning'),
+  text: z.string(),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * @internal
+ */
+export const customPartSchema: z.ZodType<CustomPart> = z.object({
+  type: z.literal('custom'),
+  kind: z.string().transform(value => value as `${string}.${string}`),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * @internal
+ */
+export const reasoningFilePartSchema: z.ZodType<ReasoningFilePart> = z.object({
+  type: z.literal('reasoning-file'),
+  data: z.union([dataContentSchema, z.instanceof(URL)]),
+  mediaType: z.string(),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
+ */
+export interface ToolCallPart {
+  type: 'tool-call';
+
+  /**
+   * ID of the tool call. This ID is used to match the tool call with the tool result.
+   */
+  toolCallId: string;
+
+  /**
+   * Name of the tool that is being called.
+   */
+  toolName: string;
+
+  /**
+   * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+   */
+  input: unknown;
+
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+}
+
+/**
+ * @internal
+ */
+export const toolCallPartSchema: z.ZodType<ToolCallPart> = z.object({
+  type: z.literal('tool-call'),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  input: z.unknown(),
+  providerOptions: providerMetadataSchema.optional(),
+  providerExecuted: z.boolean().optional(),
+}) as z.ZodType<ToolCallPart>; // necessary bc input is optional on Zod type
+
+/**
+ * @internal
+ */
+export const outputSchema: z.ZodType<ToolResultOutput> = z.discriminatedUnion(
+  'type',
+  [
+    z.object({
+      type: z.literal('text'),
+      value: z.string(),
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('json'),
+      value: jsonValueSchema,
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('execution-denied'),
+      reason: z.string().optional(),
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('error-text'),
+      value: z.string(),
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('error-json'),
+      value: jsonValueSchema,
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('content'),
+      value: z.array(
+        z.union([
+          z.object({
+            type: z.literal('text'),
+            text: z.string(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('media'),
+            data: z.string(),
+            mediaType: z.string(),
+          }),
+          z.object({
+            type: z.literal('file-data'),
+            data: z.string(),
+            mediaType: z.string(),
+            filename: z.string().optional(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('file-url'),
+            url: z.string(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('file-id'),
+            fileId: z.union([z.string(), z.record(z.string(), z.string())]),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('image-data'),
+            data: z.string(),
+            mediaType: z.string(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('image-url'),
+            url: z.string(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('image-file-id'),
+            fileId: z.union([z.string(), z.record(z.string(), z.string())]),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('custom'),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+        ]),
+      ),
+    }),
+  ],
+);
+
+/**
+ * @internal
+ */
+export const toolResultPartSchema: z.ZodType<ToolResultPart> = z.object({
+  type: z.literal('tool-result'),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  output: outputSchema,
+  providerOptions: providerMetadataSchema.optional(),
+}) as z.ZodType<ToolResultPart>; // necessary bc result is optional on Zod type
+
+/**
+ * @internal
+ */
+export const toolApprovalRequestSchema: z.ZodType<ToolApprovalRequest> =
+  z.object({
+    type: z.literal('tool-approval-request'),
+    approvalId: z.string(),
+    toolCallId: z.string(),
+  });
+
+/**
+ * @internal
+ */
+export const toolApprovalResponseSchema: z.ZodType<ToolApprovalResponse> =
+  z.object({
+    type: z.literal('tool-approval-response'),
+    approvalId: z.string(),
+    approved: z.boolean(),
+    reason: z.string().optional(),
+  });