@ai-sdk/gateway 4.0.0-beta.1 → 4.0.0-beta.108

package/src/gateway-language-model.ts

@@ -1,11 +1,9 @@
 import type {
-  LanguageModelV3,
-  LanguageModelV3CallOptions,
-  SharedV3Warning,
-  LanguageModelV3FilePart,
-  LanguageModelV3StreamPart,
-  LanguageModelV3GenerateResult,
-  LanguageModelV3StreamResult,
+  LanguageModelV4,
+  LanguageModelV4CallOptions,
+  LanguageModelV4StreamPart,
+  LanguageModelV4GenerateResult,
+  LanguageModelV4StreamResult,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
@@ -14,6 +12,9 @@ import {
   createJsonResponseHandler,
   postJsonToApi,
   resolve,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
   type ParseResult,
   type Resolvable,
 } from '@ai-sdk/provider-utils';
@@ -28,10 +29,24 @@ type GatewayChatConfig = GatewayConfig & {
   o11yHeaders: Resolvable<Record<string, string>>;
 };
 
-export class GatewayLanguageModel implements LanguageModelV3 {
-  readonly specificationVersion = 'v3';
+export class GatewayLanguageModel implements LanguageModelV4 {
+  readonly specificationVersion = 'v4';
   readonly supportedUrls = { '*/*': [/.*/] };
 
+  static [WORKFLOW_SERIALIZE](model: GatewayLanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: GatewayModelId;
+    config: GatewayChatConfig;
+  }) {
+    return new GatewayLanguageModel(options.modelId, options.config);
+  }
+
   constructor(
     readonly modelId: GatewayModelId,
     private readonly config: GatewayChatConfig,
@@ -41,7 +56,7 @@ export class GatewayLanguageModel implements LanguageModelV3 {
     return this.config.provider;
   }
 
-  private async getArgs(options: LanguageModelV3CallOptions) {
+  private async getArgs(options: LanguageModelV4CallOptions) {
     const { abortSignal: _abortSignal, ...optionsWithoutSignal } = options;
 
     return {
@@ -51,12 +66,14 @@ export class GatewayLanguageModel implements LanguageModelV3 {
   }
 
   async doGenerate(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3GenerateResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4GenerateResult> {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
 
-    const resolvedHeaders = await resolve(this.config.headers());
+    const resolvedHeaders = this.config.headers
+      ? await resolve(this.config.headers)
+      : undefined;
 
     try {
       const {
@@ -88,17 +105,22 @@ export class GatewayLanguageModel implements LanguageModelV3 {
         warnings,
       };
     } catch (error) {
-      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders ?? {}),
+      );
     }
   }
 
   async doStream(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3StreamResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4StreamResult> {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
 
-    const resolvedHeaders = await resolve(this.config.headers());
+    const resolvedHeaders = this.config.headers
+      ? await resolve(this.config.headers)
+      : undefined;
 
     try {
       const { value: response, responseHeaders } = await postJsonToApi({
@@ -122,8 +144,8 @@ export class GatewayLanguageModel implements LanguageModelV3 {
       return {
         stream: response.pipeThrough(
           new TransformStream<
-            ParseResult<LanguageModelV3StreamPart>,
-            LanguageModelV3StreamPart
+            ParseResult<LanguageModelV4StreamPart>,
+            LanguageModelV4StreamPart
           >({
             start(controller) {
               if (warnings.length > 0) {
@@ -161,36 +183,34 @@ export class GatewayLanguageModel implements LanguageModelV3 {
         response: { headers: responseHeaders },
       };
     } catch (error) {
-      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders ?? {}),
+      );
     }
   }
 
-  private isFilePart(part: unknown) {
-    return (
-      part && typeof part === 'object' && 'type' in part && part.type === 'file'
-    );
-  }
-
   /**
-   * Encodes file parts in the prompt to base64. Mutates the passed options
-   * instance directly to avoid copying the file data.
+   * Encodes inline `Uint8Array` file data to a base64 string in place.
    * @param options - The options to encode.
-   * @returns The options with the file parts encoded.
+   * @returns The options with the file data encoded.
    */
-  private maybeEncodeFileParts(options: LanguageModelV3CallOptions) {
+  private maybeEncodeFileParts(options: LanguageModelV4CallOptions) {
     for (const message of options.prompt) {
+      if (!Array.isArray(message.content)) {
+        continue;
+      }
       for (const part of message.content) {
-        if (this.isFilePart(part)) {
-          const filePart = part as LanguageModelV3FilePart;
-          // If the file part is a URL it will get cleanly converted to a string.
-          // If it's a binary file attachment we convert it to a data url.
-          // In either case, server-side we should only ever see URLs as strings.
-          if (filePart.data instanceof Uint8Array) {
-            const buffer = Uint8Array.from(filePart.data);
-            const base64Data = Buffer.from(buffer).toString('base64');
-            filePart.data = new URL(
-              `data:${filePart.mediaType || 'application/octet-stream'};base64,${base64Data}`,
-            );
+        if (part.type === 'file' || part.type === 'reasoning-file') {
+          part.data = maybeBase64EncodeFileData(part.data);
+        } else if (
+          part.type === 'tool-result' &&
+          part.output.type === 'content'
+        ) {
+          for (const contentPart of part.output.value) {
+            if (contentPart.type === 'file') {
+              contentPart.data = maybeBase64EncodeFileData(contentPart.data);
+            }
           }
         }
       }
@@ -204,9 +224,19 @@ export class GatewayLanguageModel implements LanguageModelV3 {
 
   private getModelConfigHeaders(modelId: string, streaming: boolean) {
     return {
-      'ai-language-model-specification-version': '3',
+      'ai-language-model-specification-version': '4',
       'ai-language-model-id': modelId,
       'ai-language-model-streaming': String(streaming),
     };
   }
 }
+
+function maybeBase64EncodeFileData<T extends { type: string }>(data: T): T {
+  if (data.type === 'data') {
+    const bytes = (data as { data?: unknown }).data;
+    if (bytes instanceof Uint8Array) {
+      return { ...data, data: Buffer.from(bytes).toString('base64') } as T;
+    }
+  }
+  return data;
+}

package/src/gateway-model-entry.ts

@@ -1,4 +1,16 @@
-import type { LanguageModelV3 } from '@ai-sdk/provider';
+import type { LanguageModelV4 } from '@ai-sdk/provider';
+
+export const KNOWN_MODEL_TYPES = [
+  'embedding',
+  'image',
+  'language',
+  'reranking',
+  'speech',
+  'transcription',
+  'video',
+] as const;
+
+export type KnownModelType = (typeof KNOWN_MODEL_TYPES)[number];
 
 export interface GatewayLanguageModelEntry {
   /**
@@ -49,10 +61,10 @@ export interface GatewayLanguageModelEntry {
   /**
    * Optional field to differentiate between model types.
    */
-  modelType?: 'language' | 'embedding' | 'image' | 'video' | null;
+  modelType?: KnownModelType | null;
 }
 
 export type GatewayLanguageModelSpecification = Pick<
-  LanguageModelV3,
+  LanguageModelV4,
   'specificationVersion' | 'provider' | 'modelId'
 >;

package/src/gateway-provider-options.ts

@@ -1,80 +1,52 @@
-import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
-
 // https://vercel.com/docs/ai-gateway/provider-options
-const gatewayLanguageModelOptions = lazySchema(() =>
-  zodSchema(
-    z.object({
-      /**
-       * Array of provider slugs that are the only ones allowed to be used.
-       *
-       * Example: `['azure', 'openai']` will only allow Azure and OpenAI to be used.
-       */
-      only: z.array(z.string()).optional(),
-      /**
-       * Array of provider slugs that specifies the sequence in which providers should be attempted.
-       *
-       * Example: `['bedrock', 'anthropic']` will try Amazon Bedrock first, then Anthropic as fallback.
-       */
-      order: z.array(z.string()).optional(),
-      /**
-       * The unique identifier for the end user on behalf of whom the request was made.
-       *
-       * Used for spend tracking and attribution purposes.
-       */
-      user: z.string().optional(),
-      /**
-       * User-specified tags for use in reporting and filtering usage.
-       *
-       * For example, spend tracking reporting by feature or prompt version.
-       *
-       * Example: `['chat', 'v2']`
-       */
-      tags: z.array(z.string()).optional(),
-      /**
-       * Array of model slugs specifying fallback models to use in order.
-       *
-       * Example: `['openai/gpt-5-nano', 'zai/glm-4.6']` will try `openai/gpt-5-nano` first, then `zai/glm-4.6` as fallback.
-       */
-      models: z.array(z.string()).optional(),
-      /**
-       * Request-scoped BYOK credentials to use instead of cached credentials.
-       *
-       * When provided, cached BYOK credentials are ignored entirely.
-       *
-       * Each provider can have multiple credentials (tried in order).
-       *
-       * Examples:
-       * - Simple: `{ 'anthropic': [{ apiKey: 'sk-ant-...' }] }`
-       * - Multiple: `{ 'vertex': [{ projectId: 'proj-1', privateKey: '...' }, { projectId: 'proj-2', privateKey: '...' }] }`
-       * - Multi-provider: `{ 'anthropic': [{ apiKey: '...' }], 'bedrock': [{ accessKeyId: '...', secretAccessKey: '...' }] }`
-       */
-      byok: z
-        .record(z.string(), z.array(z.record(z.string(), z.unknown())))
-        .optional(),
-      /**
-       * Whether to filter by only providers that state they have zero data
-       * retention with Vercel AI Gateway. When enabled, only providers that
-       * have agreements with Vercel AI Gateway for zero data retention will be
-       * used.
-       */
-      zeroDataRetention: z.boolean().optional(),
-      /**
-       * Per-provider timeouts for BYOK credentials in milliseconds.
-       * Controls how long to wait for a provider to start responding
-       * before falling back to the next available provider.
-       *
-       * Example: `{ byok: { openai: 5000, anthropic: 2000 } }`
-       */
-      providerTimeouts: z
-        .object({
-          byok: z.record(z.string(), z.number().int().min(1000)).optional(),
-        })
-        .optional(),
-    }),
-  ),
-);
+export type GatewayProviderOptions = {
+  /**
+   * Service-owned options may be added by the Gateway without requiring an SDK
+   * release. The Gateway service validates and applies the runtime schema.
+   */
+  [key: string]: unknown;
+
+  /** Request-scoped BYOK credentials to use instead of cached credentials. */
+  byok?: Record<string, Array<Record<string, unknown>>>;
+
+  /** Enables automatic caching behavior when supported by the Gateway. */
+  caching?: 'auto';
+
+  /** Filter to providers that do not train on prompt data. */
+  disallowPromptTraining?: boolean;
+
+  /** Filter to providers that are HIPAA compliant with Vercel AI Gateway. */
+  hipaaCompliant?: boolean;
+
+  /** Array of model slugs specifying fallback models to use in order. */
+  models?: string[];
+
+  /** Array of provider slugs that are the only ones allowed to be used. */
+  only?: string[];
+
+  /** Array of provider slugs specifying the provider attempt order. */
+  order?: string[];
+
+  /** Per-provider timeouts for BYOK credentials in milliseconds. */
+  providerTimeouts?: {
+    byok?: Record<string, number>;
+  };
+
+  /** Entity identifier against which quota is tracked. */
+  quotaEntityId?: string;
+
+  /** Unified service tier intent. */
+  serviceTier?: 'flex' | 'priority';
+
+  /** Sort providers by a performance or cost metric before routing. */
+  sort?: 'cost' | 'tps' | 'ttft';
+
+  /** User-specified tags for reporting and filtering usage. */
+  tags?: string[];
+
+  /** End-user identifier for spend tracking and attribution. */
+  user?: string;
 
-export type GatewayLanguageModelOptions = InferSchema<
-  typeof gatewayLanguageModelOptions
->;
+  /** Filter to providers with zero data retention agreements. */
+  zeroDataRetention?: boolean;
+};