@fondation-io/ai 7.0.0-beta.45

package/src/types/image-model-response-metadata.ts

@@ -0,0 +1,16 @@
+export type ImageModelResponseMetadata = {
+  /**
+   * Timestamp for the start of the generated response.
+   */
+  timestamp: Date;
+
+  /**
+   * The ID of the response model that was used to generate the response.
+   */
+  modelId: string;
+
+  /**
+   * Response headers.
+   */
+  headers?: Record<string, string>;
+};

package/src/types/image-model.ts

@@ -0,0 +1,19 @@
+import {
+  ImageModelV2,
+  ImageModelV3,
+  ImageModelV4,
+  ImageModelV4ProviderMetadata,
+  ImageModelV2ProviderMetadata,
+} from '@ai-sdk/provider';
+
+/**
+ * Image model that is used by the AI SDK.
+ */
+export type ImageModel = string | ImageModelV4 | ImageModelV3 | ImageModelV2;
+
+/**
+ * Metadata from the model provider for this call.
+ */
+export type ImageModelProviderMetadata =
+  | ImageModelV4ProviderMetadata
+  | ImageModelV2ProviderMetadata;

package/src/types/index.ts

@@ -0,0 +1,29 @@
+export type { JSONSchema7 } from '@ai-sdk/provider';
+export type { Embedding, EmbeddingModel } from './embedding-model';
+export type { EmbeddingModelMiddleware } from './embedding-model-middleware';
+export type { ImageModel, ImageModelProviderMetadata } from './image-model';
+export type { ImageModelMiddleware } from './image-model-middleware';
+export type { ImageModelResponseMetadata } from './image-model-response-metadata';
+export type { JSONValue } from './json-value';
+export type {
+  CallWarning,
+  FinishReason,
+  LanguageModel,
+  ToolChoice,
+} from './language-model';
+export type { LanguageModelMiddleware } from './language-model-middleware';
+export type { LanguageModelRequestMetadata } from './language-model-request-metadata';
+export type { LanguageModelResponseMetadata } from './language-model-response-metadata';
+export type { Provider } from './provider';
+export type { ProviderMetadata } from './provider-metadata';
+export type { RerankingModel } from './reranking-model';
+export type { SpeechModel } from './speech-model';
+export type { SpeechModelResponseMetadata } from './speech-model-response-metadata';
+export type { TranscriptionModel } from './transcription-model';
+export type { TranscriptionModelResponseMetadata } from './transcription-model-response-metadata';
+export type {
+  EmbeddingModelUsage,
+  ImageModelUsage,
+  LanguageModelUsage,
+} from './usage';
+export type { Warning } from './warning';

package/src/types/json-value.ts

@@ -0,0 +1,15 @@
+import { JSONValue as OriginalJSONValue } from '@ai-sdk/provider';
+import { z } from 'zod/v4';
+
+export const jsonValueSchema: z.ZodType<JSONValue> = z.lazy(() =>
+  z.union([
+    z.null(),
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.record(z.string(), jsonValueSchema.optional()),
+    z.array(jsonValueSchema),
+  ]),
+);
+
+export type JSONValue = OriginalJSONValue;

package/src/types/language-model-middleware.ts

@@ -0,0 +1,15 @@
+import { LanguageModelV4Middleware } from '@ai-sdk/provider';
+
+/**
+ * Middleware for language models.
+ * Accepts both V3 and V4 middleware types for backward compatibility.
+ *
+ * Uses LanguageModelV4Middleware as the base but relaxes specificationVersion
+ * to accept any string (including 'v3') and makes it optional.
+ */
+export type LanguageModelMiddleware = Omit<
+  LanguageModelV4Middleware,
+  'specificationVersion'
+> & {
+  readonly specificationVersion?: string;
+};

package/src/types/language-model-request-metadata.ts

@@ -0,0 +1,6 @@
+export type LanguageModelRequestMetadata = {
+  /**
+   * Request HTTP body that was sent to the provider API.
+   */
+  body?: unknown;
+};

package/src/types/language-model-response-metadata.ts

@@ -0,0 +1,21 @@
+export type LanguageModelResponseMetadata = {
+  /**
+   * ID for the generated response.
+   */
+  id: string;
+
+  /**
+   * Timestamp for the start of the generated response.
+   */
+  timestamp: Date;
+
+  /**
+   * The ID of the response model that was used to generate the response.
+   */
+  modelId: string;
+
+  /**
+   * Response headers (available only for providers that use HTTP requests).
+   */
+  headers?: Record<string, string>;
+};

package/src/types/language-model.ts

@@ -0,0 +1,106 @@
+import { GatewayModelId } from '@ai-sdk/gateway';
+import {
+  LanguageModelV2,
+  LanguageModelV3,
+  LanguageModelV4,
+  SharedV4Warning,
+  LanguageModelV4Source,
+} from '@ai-sdk/provider';
+
+declare global {
+  /**
+   * Global interface that can be augmented by third-party packages to register custom model IDs.
+   *
+   * You can register model IDs in two ways:
+   *
+   * 1. Register based on Model IDs from a provider package:
+   * @example
+   * ```typescript
+   * import { openai } from '@ai-sdk/openai';
+   * type OpenAIResponsesModelId = Parameters<typeof openai>[0];
+   *
+   * declare global {
+   *   interface RegisteredProviderModels {
+   *     openai: OpenAIResponsesModelId;
+   *   }
+   * }
+   * ```
+   *
+   * 2. Register individual model IDs directly as keys:
+   * @example
+   * ```typescript
+   * declare global {
+   *   interface RegisteredProviderModels {
+   *     'my-provider:my-model': any;
+   *     'my-provider:another-model': any;
+   *   }
+   * }
+   * ```
+   */
+  interface RegisteredProviderModels {}
+}
+
+/**
+ * Global provider model ID type that defaults to GatewayModelId but can be augmented
+ * by third-party packages via declaration merging.
+ */
+export type GlobalProviderModelId = [keyof RegisteredProviderModels] extends [
+  never,
+]
+  ? GatewayModelId
+  :
+      | keyof RegisteredProviderModels
+      | RegisteredProviderModels[keyof RegisteredProviderModels];
+
+/**
+ * Language model that is used by the AI SDK.
+ */
+export type LanguageModel =
+  | GlobalProviderModelId
+  | LanguageModelV4
+  | LanguageModelV3
+  | LanguageModelV2;
+
+/**
+ * Reason why a language model finished generating a response.
+ *
+ * Can be one of the following:
+ * - `stop`: model generated stop sequence
+ * - `length`: model generated maximum number of tokens
+ * - `content-filter`: content filter violation stopped the model
+ * - `tool-calls`: model triggered tool calls
+ * - `error`: model stopped because of an error
+ * - `other`: model stopped for other reasons
+ */
+export type FinishReason =
+  | 'stop'
+  | 'length'
+  | 'content-filter'
+  | 'tool-calls'
+  | 'error'
+  | 'other';
+
+/**
+ * Warning from the model provider for this call. The call will proceed, but e.g.
+ * some settings might not be supported, which can lead to suboptimal results.
+ */
+export type CallWarning = SharedV4Warning;
+
+/**
+ * A source that has been used as input to generate the response.
+ */
+export type Source = LanguageModelV4Source;
+
+/**
+ * Tool choice for the generation. It supports the following settings:
+ *
+ * - `auto` (default): the model can choose whether and which tools to call.
+ * - `required`: the model must call a tool. It can choose which tool to call.
+ * - `none`: the model must not call tools
+ * - `{ type: 'tool', toolName: string (typed) }`: the model must call the specified tool
+ */
+export type ToolChoice<TOOLS extends Record<string, unknown>> =
+  | 'auto'
+  | 'none'
+  | 'required'
+  | { type: 'tool'; toolName: Extract<keyof TOOLS, string> };

package/src/types/provider-metadata.ts

@@ -0,0 +1,16 @@
+import { SharedV4ProviderMetadata } from '@ai-sdk/provider';
+import { z } from 'zod/v4';
+import { jsonValueSchema } from './json-value';
+
+/**
+ * Additional provider-specific metadata that is returned from the provider.
+ *
+ * This is needed to enable provider-specific functionality that can be
+ * fully encapsulated in the provider.
+ */
+export type ProviderMetadata = SharedV4ProviderMetadata;
+
+export const providerMetadataSchema: z.ZodType<ProviderMetadata> = z.record(
+  z.string(),
+  z.record(z.string(), jsonValueSchema.optional()),
+);

package/src/types/provider.ts

@@ -0,0 +1,55 @@
+import { EmbeddingModel } from './embedding-model';
+import { LanguageModel } from './language-model';
+import { ImageModel } from './image-model';
+import { RerankingModel } from './reranking-model';
+
+/**
+ * Provider for language, text embedding, and image models.
+ */
+export type Provider = {
+  /**
+   * Returns the language model with the given id.
+   * The model id is then passed to the provider function to get the model.
+   *
+   * @param {string} modelId - The id of the model to return.
+   *
+   * @returns {LanguageModel} The language model associated with the id
+   *
+   * @throws {NoSuchModelError} If no such model exists.
+   */
+  languageModel(modelId: string): LanguageModel;
+
+  /**
+   * Returns the text embedding model with the given id.
+   * The model id is then passed to the provider function to get the model.
+   *
+   * @param {string} modelId - The id of the model to return.
+   *
+   * @returns {EmbeddingModel} The embedding model associated with the id
+   *
+   * @throws {NoSuchModelError} If no such model exists.
+   */
+  embeddingModel(modelId: string): EmbeddingModel;
+
+  /**
+   * Returns the image model with the given id.
+   * The model id is then passed to the provider function to get the model.
+   *
+   * @param {string} modelId - The id of the model to return.
+   *
+   * @returns {ImageModel} The image model associated with the id
+   */
+  imageModel(modelId: string): ImageModel;
+
+  /**
+   * Returns the reranking model with the given id.
+   * The model id is then passed to the provider function to get the model.
+   *
+   * @param {string} modelId - The id of the model to return.
+   *
+   * @returns {RerankingModel} The reranking model associated with the id
+   *
+   * @throws {NoSuchModelError} If no such model exists.
+   */
+  rerankingModel(modelId: string): RerankingModel;
+};

package/src/types/reranking-model.ts

@@ -0,0 +1,6 @@
+import { RerankingModelV3, RerankingModelV4 } from '@ai-sdk/provider';
+
+/**
+ * Reranking model that is used by the AI SDK.
+ */
+export type RerankingModel = RerankingModelV4 | RerankingModelV3;

package/src/types/speech-model-response-metadata.ts

@@ -0,0 +1,21 @@
+export type SpeechModelResponseMetadata = {
+  /**
+   * Timestamp for the start of the generated response.
+   */
+  timestamp: Date;
+
+  /**
+   * The ID of the response model that was used to generate the response.
+   */
+  modelId: string;
+
+  /**
+   * Response headers.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * Response body.
+   */
+  body?: unknown;
+};

package/src/types/speech-model.ts

@@ -0,0 +1,10 @@
+import { SpeechModelV2, SpeechModelV3, SpeechModelV4 } from '@ai-sdk/provider';
+
+/**
+ * Speech model that is used by the AI SDK.
+ */
+export type SpeechModel =
+  | string
+  | SpeechModelV4
+  | SpeechModelV3
+  | SpeechModelV2;

package/src/types/transcription-model-response-metadata.ts

@@ -0,0 +1,16 @@
+export type TranscriptionModelResponseMetadata = {
+  /**
+   * Timestamp for the start of the generated response.
+   */
+  timestamp: Date;
+
+  /**
+   * The ID of the response model that was used to generate the response.
+   */
+  modelId: string;
+
+  /**
+   * Response headers.
+   */
+  headers?: Record<string, string>;
+};

package/src/types/transcription-model.ts

@@ -0,0 +1,14 @@
+import {
+  TranscriptionModelV2,
+  TranscriptionModelV3,
+  TranscriptionModelV4,
+} from '@ai-sdk/provider';
+
+/**
+ * Transcription model that is used by the AI SDK.
+ */
+export type TranscriptionModel =
+  | string
+  | TranscriptionModelV4
+  | TranscriptionModelV3
+  | TranscriptionModelV2;

package/src/types/usage.ts

@@ -0,0 +1,200 @@
+import {
+  ImageModelV4Usage,
+  JSONObject,
+  LanguageModelV4Usage,
+} from '@ai-sdk/provider';
+
+/**
+ * Represents the number of tokens used in a prompt and completion.
+ */
+export type LanguageModelUsage = {
+  /**
+   * The total number of input (prompt) tokens used.
+   */
+  inputTokens: number | undefined;
+
+  /**
+   * Detailed information about the input tokens.
+   */
+  inputTokenDetails: {
+    /**
+     * The number of non-cached input (prompt) tokens used.
+     */
+    noCacheTokens: number | undefined;
+
+    /**
+     * The number of cached input (prompt) tokens read.
+     */
+    cacheReadTokens: number | undefined;
+
+    /**
+     * The number of cached input (prompt) tokens written.
+     */
+    cacheWriteTokens: number | undefined;
+  };
+
+  /**
+   * The number of total output (completion) tokens used.
+   */
+  outputTokens: number | undefined;
+
+  /**
+   * Detailed information about the output tokens.
+   */
+  outputTokenDetails: {
+    /**
+     * The number of text tokens used.
+     */
+    textTokens: number | undefined;
+
+    /**
+     * The number of reasoning tokens used.
+     */
+    reasoningTokens: number | undefined;
+  };
+
+  /**
+   * The total number of tokens used.
+   */
+  totalTokens: number | undefined;
+
+  /**
+   * @deprecated Use outputTokenDetails.reasoningTokens instead.
+   */
+  reasoningTokens?: number | undefined;
+
+  /**
+   * @deprecated Use inputTokenDetails.cacheReadTokens instead.
+   */
+  cachedInputTokens?: number | undefined;
+
+  /**
+   * Raw usage information from the provider.
+   *
+   * This is the usage information in the shape that the provider returns.
+   * It can include additional information that is not part of the standard usage information.
+   */
+  raw?: JSONObject;
+};
+
+/**
+ * Represents the number of tokens used in an embedding.
+ */
+// TODO replace with EmbeddingModelV4Usage once available in @ai-sdk/provider
+export type EmbeddingModelUsage = {
+  /**
+   * The number of tokens used in the embedding.
+   */
+  tokens: number;
+};
+
+export function asLanguageModelUsage(
+  usage: LanguageModelV4Usage,
+): LanguageModelUsage {
+  return {
+    inputTokens: usage.inputTokens.total,
+    inputTokenDetails: {
+      noCacheTokens: usage.inputTokens.noCache,
+      cacheReadTokens: usage.inputTokens.cacheRead,
+      cacheWriteTokens: usage.inputTokens.cacheWrite,
+    },
+    outputTokens: usage.outputTokens.total,
+    outputTokenDetails: {
+      textTokens: usage.outputTokens.text,
+      reasoningTokens: usage.outputTokens.reasoning,
+    },
+    totalTokens: addTokenCounts(
+      usage.inputTokens.total,
+      usage.outputTokens.total,
+    ),
+    raw: usage.raw,
+    reasoningTokens: usage.outputTokens.reasoning,
+    cachedInputTokens: usage.inputTokens.cacheRead,
+  };
+}
+
+export function createNullLanguageModelUsage(): LanguageModelUsage {
+  return {
+    inputTokens: undefined,
+    inputTokenDetails: {
+      noCacheTokens: undefined,
+      cacheReadTokens: undefined,
+      cacheWriteTokens: undefined,
+    },
+    outputTokens: undefined,
+    outputTokenDetails: {
+      textTokens: undefined,
+      reasoningTokens: undefined,
+    },
+    totalTokens: undefined,
+    raw: undefined,
+  };
+}
+
+export function addLanguageModelUsage(
+  usage1: LanguageModelUsage,
+  usage2: LanguageModelUsage,
+): LanguageModelUsage {
+  return {
+    inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
+    inputTokenDetails: {
+      noCacheTokens: addTokenCounts(
+        usage1.inputTokenDetails?.noCacheTokens,
+        usage2.inputTokenDetails?.noCacheTokens,
+      ),
+      cacheReadTokens: addTokenCounts(
+        usage1.inputTokenDetails?.cacheReadTokens,
+        usage2.inputTokenDetails?.cacheReadTokens,
+      ),
+      cacheWriteTokens: addTokenCounts(
+        usage1.inputTokenDetails?.cacheWriteTokens,
+        usage2.inputTokenDetails?.cacheWriteTokens,
+      ),
+    },
+    outputTokens: addTokenCounts(usage1.outputTokens, usage2.outputTokens),
+    outputTokenDetails: {
+      textTokens: addTokenCounts(
+        usage1.outputTokenDetails?.textTokens,
+        usage2.outputTokenDetails?.textTokens,
+      ),
+      reasoningTokens: addTokenCounts(
+        usage1.outputTokenDetails?.reasoningTokens,
+        usage2.outputTokenDetails?.reasoningTokens,
+      ),
+    },
+    totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens),
+    reasoningTokens: addTokenCounts(
+      usage1.reasoningTokens,
+      usage2.reasoningTokens,
+    ),
+    cachedInputTokens: addTokenCounts(
+      usage1.cachedInputTokens,
+      usage2.cachedInputTokens,
+    ),
+  };
+}
+
+function addTokenCounts(
+  tokenCount1: number | undefined,
+  tokenCount2: number | undefined,
+): number | undefined {
+  return tokenCount1 == null && tokenCount2 == null
+    ? undefined
+    : (tokenCount1 ?? 0) + (tokenCount2 ?? 0);
+}
+
+/**
+ * Usage information for an image model call.
+ */
+export type ImageModelUsage = ImageModelV4Usage;
+
+export function addImageModelUsage(
+  usage1: ImageModelUsage,
+  usage2: ImageModelUsage,
+): ImageModelUsage {
+  return {
+    inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
+    outputTokens: addTokenCounts(usage1.outputTokens, usage2.outputTokens),
+    totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens),
+  };
+}

package/src/types/video-model-response-metadata.ts

@@ -0,0 +1,28 @@
+import type { SharedV4ProviderMetadata } from '@ai-sdk/provider';
+
+/**
+ * Response metadata for a video model call.
+ */
+export type VideoModelResponseMetadata = {
+  /**
+   * Timestamp for the start of the generated response.
+   */
+  timestamp: Date;
+
+  /**
+   * The ID of the response model that was used to generate the response.
+   */
+  modelId: string;
+
+  /**
+   * Response headers.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * Provider-specific metadata for this call.
+   * When multiple calls are made (n > maxVideosPerCall), each response
+   * contains its own providerMetadata, allowing lossless per-call access.
+   */
+  providerMetadata?: SharedV4ProviderMetadata;
+};

package/src/types/video-model.ts

@@ -0,0 +1,15 @@
+import {
+  Experimental_VideoModelV3,
+  Experimental_VideoModelV4,
+  SharedV4ProviderMetadata,
+} from '@ai-sdk/provider';
+
+/**
+ * A video model can be a string (model ID) or a video model object.
+ */
+export type VideoModel =
+  | string
+  | Experimental_VideoModelV4
+  | Experimental_VideoModelV3;
+
+export type VideoModelProviderMetadata = SharedV4ProviderMetadata;

package/src/types/warning.ts

@@ -0,0 +1,7 @@
+import { SharedV4Warning } from '@ai-sdk/provider';
+
+/**
+ * Warning from the model provider for this call. The call will proceed, but e.g.
+ * some settings might not be supported, which can lead to suboptimal results.
+ */
+export type Warning = SharedV4Warning;