@ai-sdk/gateway 4.0.120 → 4.0.121

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ai-sdk/gateway",
   "private": false,
-  "version": "4.0.120",
+  "version": "4.0.121",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.31",
-    "@ai-sdk/provider-utils": "5.0.64",
+    "@ai-sdk/provider-utils": "5.0.65",
     "@vercel/oidc": "3.2.0"
   },
   "devDependencies": {

package/src/gateway-batch.ts

@@ -14,6 +14,8 @@ import {
   type SharedV4ProviderOptions,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   convertAsyncIteratorToReadableStream,
   createJsonErrorResponseHandler,
@@ -485,55 +487,66 @@ async function* convertGatewayBatchResultLines(
   }
 }
 
-const gatewayBatchItemResultLineSchema = z
-  .object({
-    type: z.literal('text'),
-    id: z.string(),
-    status: z.enum(['cancelled', 'expired', 'failed', 'succeeded']),
-  })
-  .catchall(z.unknown());
-
-const gatewayBatchErrorSchema = z.object({
-  message: z.string(),
-  type: z.string().nullish(),
-  code: z.string().nullish(),
-  statusCode: z.number().nullish(),
-});
-
-const gatewayBatchRequestCountsSchema = z.object({
-  total: z.number().nullish(),
-  pending: z.number().nullish(),
-  completed: z.number().nullish(),
-  failed: z.number().nullish(),
-});
-
-const gatewayBatchProviderMetadataSchema = z.record(
-  z.string(),
-  z.record(z.string(), z.unknown()),
+const gatewayBatchItemResultLineSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        type: z.literal('text'),
+        id: z.string(),
+        status: z.enum(['cancelled', 'expired', 'failed', 'succeeded']),
+      })
+      .catchall(z.unknown()),
+  ),
 );
 
-const gatewayBatchStatusFieldsSchema = z.object({
-  status: z.enum(['completed', 'failed', 'pending']),
-  rawStatus: z.string().nullish(),
-  requestCounts: gatewayBatchRequestCountsSchema.nullish(),
-  error: gatewayBatchErrorSchema.nullish(),
-  createdAt: z.string().nullish(),
-  expiresAt: z.string().nullish(),
-  providerMetadata: gatewayBatchProviderMetadataSchema.nullish(),
-});
-
-const gatewayBatchStartResponseSchema = gatewayBatchStatusFieldsSchema.extend({
-  batchId: z.string(),
-  warnings: z
-    .array(
-      z
-        .object({
-          requestId: z.string().nullish(),
-          warning: z.unknown(),
-        })
-        .catchall(z.unknown()),
-    )
-    .nullish(),
-});
-
-const gatewayBatchStatusResponseSchema = gatewayBatchStatusFieldsSchema;
+const gatewayBatchErrorSchema = () =>
+  z.object({
+    message: z.string(),
+    type: z.string().nullish(),
+    code: z.string().nullish(),
+    statusCode: z.number().nullish(),
+  });
+
+const gatewayBatchRequestCountsSchema = () =>
+  z.object({
+    total: z.number().nullish(),
+    pending: z.number().nullish(),
+    completed: z.number().nullish(),
+    failed: z.number().nullish(),
+  });
+
+const gatewayBatchProviderMetadataSchema = () =>
+  z.record(z.string(), z.record(z.string(), z.unknown()));
+
+const gatewayBatchStatusFieldsSchema = () =>
+  z.object({
+    status: z.enum(['completed', 'failed', 'pending']),
+    rawStatus: z.string().nullish(),
+    requestCounts: gatewayBatchRequestCountsSchema().nullish(),
+    error: gatewayBatchErrorSchema().nullish(),
+    createdAt: z.string().nullish(),
+    expiresAt: z.string().nullish(),
+    providerMetadata: gatewayBatchProviderMetadataSchema().nullish(),
+  });
+
+const gatewayBatchStartResponseSchema = lazySchema(() =>
+  zodSchema(
+    gatewayBatchStatusFieldsSchema().extend({
+      batchId: z.string(),
+      warnings: z
+        .array(
+          z
+            .object({
+              requestId: z.string().nullish(),
+              warning: z.unknown(),
+            })
+            .catchall(z.unknown()),
+        )
+        .nullish(),
+    }),
+  ),
+);
+
+const gatewayBatchStatusResponseSchema = lazySchema(() =>
+  zodSchema(gatewayBatchStatusFieldsSchema()),
+);

package/src/gateway-decision-model.ts

@@ -135,52 +135,54 @@ export class GatewayDecisionModel implements DecisionModelV4 {
   }
 }
 
-const gatewayDecisionAnswerSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal('choice'),
-    choice: z.string(),
-    probabilities: z.record(z.string(), z.number()).optional(),
-  }),
-  z.object({
-    type: z.literal('score'),
-    score: z.number(),
-    probabilities: z.record(z.string(), z.number()).optional(),
-  }),
-  z.object({
-    type: z.literal('boolean'),
-    probability: z.number(),
-  }),
-  z.object({
-    type: z.literal('refusal'),
-  }),
-]);
+const gatewayDecisionAnswerSchema = () =>
+  z.discriminatedUnion('type', [
+    z.object({
+      type: z.literal('choice'),
+      choice: z.string(),
+      probabilities: z.record(z.string(), z.number()).optional(),
+    }),
+    z.object({
+      type: z.literal('score'),
+      score: z.number(),
+      probabilities: z.record(z.string(), z.number()).optional(),
+    }),
+    z.object({
+      type: z.literal('boolean'),
+      probability: z.number(),
+    }),
+    z.object({
+      type: z.literal('refusal'),
+    }),
+  ]);
 
-const gatewayDecisionWarningSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal('unsupported'),
-    feature: z.string(),
-    details: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal('compatibility'),
-    feature: z.string(),
-    details: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal('deprecated'),
-    setting: z.string(),
-    message: z.string(),
-  }),
-  z.object({
-    type: z.literal('other'),
-    message: z.string(),
-  }),
-]);
+const gatewayDecisionWarningSchema = () =>
+  z.discriminatedUnion('type', [
+    z.object({
+      type: z.literal('unsupported'),
+      feature: z.string(),
+      details: z.string().optional(),
+    }),
+    z.object({
+      type: z.literal('compatibility'),
+      feature: z.string(),
+      details: z.string().optional(),
+    }),
+    z.object({
+      type: z.literal('deprecated'),
+      setting: z.string(),
+      message: z.string(),
+    }),
+    z.object({
+      type: z.literal('other'),
+      message: z.string(),
+    }),
+  ]);
 
 const gatewayDecisionResponseSchema = lazySchema(() =>
   zodSchema(
     z.object({
-      answers: z.record(z.string(), gatewayDecisionAnswerSchema),
+      answers: z.record(z.string(), gatewayDecisionAnswerSchema()),
       model: z.string().optional(),
       rounding: z
         .object({
@@ -194,7 +196,7 @@ const gatewayDecisionResponseSchema = lazySchema(() =>
           outputTokens: z.number().optional(),
         })
         .optional(),
-      warnings: z.array(gatewayDecisionWarningSchema).optional(),
+      warnings: z.array(gatewayDecisionWarningSchema()).optional(),
       providerMetadata: z
         .record(z.string(), z.record(z.string(), z.unknown()))
         .optional(),

package/src/gateway-embedding-model.ts

@@ -123,34 +123,35 @@ export class GatewayEmbeddingModel implements EmbeddingModelV4 {
   }
 }
 
-const gatewayEmbeddingWarningSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal('unsupported'),
-    feature: z.string(),
-    details: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal('compatibility'),
-    feature: z.string(),
-    details: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal('deprecated'),
-    setting: z.string(),
-    message: z.string(),
-  }),
-  z.object({
-    type: z.literal('other'),
-    message: z.string(),
-  }),
-]);
+const gatewayEmbeddingWarningSchema = () =>
+  z.discriminatedUnion('type', [
+    z.object({
+      type: z.literal('unsupported'),
+      feature: z.string(),
+      details: z.string().optional(),
+    }),
+    z.object({
+      type: z.literal('compatibility'),
+      feature: z.string(),
+      details: z.string().optional(),
+    }),
+    z.object({
+      type: z.literal('deprecated'),
+      setting: z.string(),
+      message: z.string(),
+    }),
+    z.object({
+      type: z.literal('other'),
+      message: z.string(),
+    }),
+  ]);
 
 const gatewayEmbeddingResponseSchema = lazySchema(() =>
   zodSchema(
     z.object({
       embeddings: z.array(z.array(z.number())),
       usage: z.object({ tokens: z.number() }).nullish(),
-      warnings: z.array(gatewayEmbeddingWarningSchema).optional(),
+      warnings: z.array(gatewayEmbeddingWarningSchema()).optional(),
       providerMetadata: z
         .record(z.string(), z.record(z.string(), z.unknown()))
         .optional(),

package/src/gateway-image-model.ts

@@ -4,6 +4,8 @@ import type {
   ImageModelV4ProviderMetadata,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   convertUint8ArrayToBase64,
   createJsonErrorResponseHandler,
@@ -154,46 +156,53 @@ function maybeEncodeImageFile(file: ImageModelV4File) {
   return file;
 }
 
-const providerMetadataEntrySchema = z
-  .object({
-    images: z.array(z.unknown()).optional(),
-  })
-  .catchall(z.unknown());
+const providerMetadataEntrySchema = () =>
+  z
+    .object({
+      images: z.array(z.unknown()).optional(),
+    })
+    .catchall(z.unknown());
 
-const gatewayImageWarningSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal('unsupported'),
-    feature: z.string(),
-    details: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal('compatibility'),
-    feature: z.string(),
-    details: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal('deprecated'),
-    setting: z.string(),
-    message: z.string(),
-  }),
-  z.object({
-    type: z.literal('other'),
-    message: z.string(),
-  }),
-]);
+const gatewayImageWarningSchema = () =>
+  z.discriminatedUnion('type', [
+    z.object({
+      type: z.literal('unsupported'),
+      feature: z.string(),
+      details: z.string().optional(),
+    }),
+    z.object({
+      type: z.literal('compatibility'),
+      feature: z.string(),
+      details: z.string().optional(),
+    }),
+    z.object({
+      type: z.literal('deprecated'),
+      setting: z.string(),
+      message: z.string(),
+    }),
+    z.object({
+      type: z.literal('other'),
+      message: z.string(),
+    }),
+  ]);
 
-const gatewayImageUsageSchema = z.object({
-  inputTokens: z.number().nullish(),
-  outputTokens: z.number().nullish(),
-  totalTokens: z.number().nullish(),
-});
+const gatewayImageUsageSchema = () =>
+  z.object({
+    inputTokens: z.number().nullish(),
+    outputTokens: z.number().nullish(),
+    totalTokens: z.number().nullish(),
+  });
 
-const gatewayImageResponseSchema = z.object({
-  images: z.array(z.string()), // Always base64 strings over the wire
-  isRetryable: z.boolean().optional(),
-  warnings: z.array(gatewayImageWarningSchema).optional(),
-  providerMetadata: z
-    .record(z.string(), providerMetadataEntrySchema)
-    .optional(),
-  usage: gatewayImageUsageSchema.optional(),
-});
+const gatewayImageResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      images: z.array(z.string()), // Always base64 strings over the wire
+      isRetryable: z.boolean().optional(),
+      warnings: z.array(gatewayImageWarningSchema()).optional(),
+      providerMetadata: z
+        .record(z.string(), providerMetadataEntrySchema())
+        .optional(),
+      usage: gatewayImageUsageSchema().optional(),
+    }),
+  ),
+);

package/src/gateway-provider-options.ts

@@ -11,7 +11,7 @@ export const gatewayDecisionProviderOptionsSchema = lazySchema(() =>
   zodSchema(
     z
       .object({
-        models: gatewayModelFallbacksSchema.optional(),
+        models: gatewayModelFallbacksSchema().optional(),
       })
       .catchall(z.unknown()),
   ),
@@ -156,79 +156,81 @@ type GatewayModelFallbackList<QUESTION_ID extends string> =
   | string[]
   | [ConditionalGatewayModelFallback<QUESTION_ID>, ...string[]];
 
-const probabilitySchema = z.number().finite().min(0).max(1);
-const questionSchema = z
-  .string()
-  .min(1)
-  .max(DECISION_FALLBACK_MAX_QUESTION_LENGTH);
-const directConditionSchema = z.union([
+const probabilitySchema = () => z.number().finite().min(0).max(1);
+const questionSchema = () =>
+  z.string().min(1).max(DECISION_FALLBACK_MAX_QUESTION_LENGTH);
+const directConditionSchema = () =>
+  z.union([
+    z
+      .object({
+        question: questionSchema().optional(),
+        confidenceBelow: probabilitySchema(),
+      })
+      .strict(),
+    z
+      .object({
+        question: questionSchema().optional(),
+        probabilityBetween: z
+          .array(probabilitySchema())
+          .length(2)
+          .refine(([minimum, maximum]) => minimum <= maximum, {
+            message:
+              'probabilityBetween minimum must be less than or equal to maximum',
+          }),
+      })
+      .strict(),
+  ]) as ZodType<DecisionFallbackCondition>;
+
+const groupBeyondMaxDepthSchema = () =>
+  z
+    .union([
+      z.object({ any: z.unknown() }),
+      z.object({ all: z.unknown() }),
+      z.object({ atLeast: z.unknown() }),
+    ])
+    .superRefine((_, context) => {
+      context.addIssue({
+        code: 'custom',
+        message: `conditions can be nested at most ${DECISION_FALLBACK_MAX_CONDITION_DEPTH} levels deep`,
+      });
+    });
+
+const conditionalModelFallbackSchema = () =>
   z
     .object({
-      question: questionSchema.optional(),
-      confidenceBelow: probabilitySchema,
+      model: z.string().min(1),
+      when: conditionSchema(1),
     })
-    .strict(),
+    .strict();
+
+const gatewayModelFallbacksSchema = () =>
   z
-    .object({
-      question: questionSchema.optional(),
-      probabilityBetween: z
-        .array(probabilitySchema)
-        .length(2)
-        .refine(([minimum, maximum]) => minimum <= maximum, {
+    .array(z.union([z.string(), conditionalModelFallbackSchema()]))
+    .superRefine((entries, context) => {
+      const conditionalIndexes = entries.flatMap((entry, index) =>
+        typeof entry === 'string' ? [] : [index],
+      );
+      if (conditionalIndexes.length > 1) {
+        context.addIssue({
+          code: 'custom',
+          message: 'models supports at most one conditional decision fallback',
+        });
+      }
+      if (conditionalIndexes[0] !== undefined && conditionalIndexes[0] !== 0) {
+        context.addIssue({
+          code: 'custom',
           message:
-            'probabilityBetween minimum must be less than or equal to maximum',
-        }),
-    })
-    .strict(),
-]) as ZodType<DecisionFallbackCondition>;
-
-const groupBeyondMaxDepthSchema = z
-  .union([
-    z.object({ any: z.unknown() }),
-    z.object({ all: z.unknown() }),
-    z.object({ atLeast: z.unknown() }),
-  ])
-  .superRefine((_, context) => {
-    context.addIssue({
-      code: 'custom',
-      message: `conditions can be nested at most ${DECISION_FALLBACK_MAX_CONDITION_DEPTH} levels deep`,
+            'a conditional decision fallback must be the first models entry',
+          path: [conditionalIndexes[0]],
+        });
+      }
     });
-  });
-
-const conditionalModelFallbackSchema = z
-  .object({
-    model: z.string().min(1),
-    when: conditionSchema(1),
-  })
-  .strict();
-
-const gatewayModelFallbacksSchema = z
-  .array(z.union([z.string(), conditionalModelFallbackSchema]))
-  .superRefine((entries, context) => {
-    const conditionalIndexes = entries.flatMap((entry, index) =>
-      typeof entry === 'string' ? [] : [index],
-    );
-    if (conditionalIndexes.length > 1) {
-      context.addIssue({
-        code: 'custom',
-        message: 'models supports at most one conditional decision fallback',
-      });
-    }
-    if (conditionalIndexes[0] !== undefined && conditionalIndexes[0] !== 0) {
-      context.addIssue({
-        code: 'custom',
-        message:
-          'a conditional decision fallback must be the first models entry',
-        path: [conditionalIndexes[0]],
-      });
-    }
-  });
 
 function conditionSchema(depth: number): ZodType<DecisionFallbackCondition> {
   if (depth === DECISION_FALLBACK_MAX_CONDITION_DEPTH) {
     return z.union([
-      directConditionSchema,
-      groupBeyondMaxDepthSchema,
+      directConditionSchema(),
+      groupBeyondMaxDepthSchema(),
     ]) as ZodType<DecisionFallbackCondition>;
   }
 
@@ -239,7 +241,7 @@ function conditionSchema(depth: number): ZodType<DecisionFallbackCondition> {
     .max(DECISION_FALLBACK_MAX_CONDITIONS_PER_LIST);
 
   return z.union([
-    directConditionSchema,
+    directConditionSchema(),
     z.object({ any: conditionListSchema }).strict(),
     z.object({ all: conditionListSchema }).strict(),
     z

package/src/gateway-provider.ts

@@ -1,4 +1,6 @@
 import {
+  lazySchema,
+  zodSchema,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   getErrorMessage,
@@ -309,10 +311,14 @@ export interface GatewayProviderSettings {
 const AI_GATEWAY_PROTOCOL_VERSION = '0.0.1';
 
 /** Response shape of `POST /v1/realtime/client-secrets`. `expiresAt` is epoch seconds. */
-const gatewayClientSecretResponseSchema = z.object({
-  token: z.string(),
-  expiresAt: z.number().nullish(),
-});
+const gatewayClientSecretResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      token: z.string(),
+      expiresAt: z.number().nullish(),
+    }),
+  ),
+);
 
 /**
  * Create a remote provider instance.

package/src/gateway-reranking-model.ts

@@ -103,27 +103,28 @@ export class GatewayRerankingModel implements RerankingModelV4 {
   }
 }
 
-const gatewayRerankingWarningSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal('unsupported'),
-    feature: z.string(),
-    details: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal('compatibility'),
-    feature: z.string(),
-    details: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal('deprecated'),
-    setting: z.string(),
-    message: z.string(),
-  }),
-  z.object({
-    type: z.literal('other'),
-    message: z.string(),
-  }),
-]);
+const gatewayRerankingWarningSchema = () =>
+  z.discriminatedUnion('type', [
+    z.object({
+      type: z.literal('unsupported'),
+      feature: z.string(),
+      details: z.string().optional(),
+    }),
+    z.object({
+      type: z.literal('compatibility'),
+      feature: z.string(),
+      details: z.string().optional(),
+    }),
+    z.object({
+      type: z.literal('deprecated'),
+      setting: z.string(),
+      message: z.string(),
+    }),
+    z.object({
+      type: z.literal('other'),
+      message: z.string(),
+    }),
+  ]);
 
 const gatewayRerankingResponseSchema = lazySchema(() =>
   zodSchema(
@@ -134,7 +135,7 @@ const gatewayRerankingResponseSchema = lazySchema(() =>
           relevanceScore: z.number(),
         }),
       ),
-      warnings: z.array(gatewayRerankingWarningSchema).optional(),
+      warnings: z.array(gatewayRerankingWarningSchema()).optional(),
       providerMetadata: z
         .record(z.string(), z.record(z.string(), z.unknown()))
         .optional(),