@ai-sdk/gateway 3.0.130 → 3.0.132

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ai-sdk/gateway",
   "private": false,
-  "version": "3.0.130",
+  "version": "3.0.132",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",

package/src/errors/create-gateway-error.ts

@@ -9,6 +9,7 @@ import {
 } from './gateway-model-not-found-error';
 import { GatewayInternalServerError } from './gateway-internal-server-error';
 import { GatewayFailedDependencyError } from './gateway-failed-dependency-error';
+import { GatewayForbiddenError } from './gateway-forbidden-error';
 import { GatewayResponseError } from './gateway-response-error';
 import {
   lazySchema,
@@ -111,6 +112,13 @@ export async function createGatewayErrorFromResponse({
         cause,
         generationId,
       });
+    case 'forbidden':
+      return new GatewayForbiddenError({
+        message,
+        statusCode,
+        cause,
+        generationId,
+      });
     default:
       return new GatewayInternalServerError({
         message,

package/src/errors/gateway-forbidden-error.ts

@@ -0,0 +1,34 @@
+import { GatewayError } from './gateway-error';
+
+const name = 'GatewayForbiddenError';
+const marker = `vercel.ai.gateway.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Forbidden - the request was rejected by policy (e.g. a routing rule),
+ * not an authentication failure.
+ */
+export class GatewayForbiddenError extends GatewayError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly name = name;
+  readonly type = 'forbidden';
+
+  constructor({
+    message = 'Forbidden',
+    statusCode = 403,
+    cause,
+    generationId,
+  }: {
+    message?: string;
+    statusCode?: number;
+    cause?: unknown;
+    generationId?: string;
+  } = {}) {
+    super({ message, statusCode, cause, generationId });
+  }
+
+  static isInstance(error: unknown): error is GatewayForbiddenError {
+    return GatewayError.hasMarker(error) && symbol in error;
+  }
+}

package/src/errors/index.ts

@@ -7,6 +7,7 @@ export { extractApiCallResponse } from './extract-api-call-response';
 export { GatewayError } from './gateway-error';
 export { GatewayAuthenticationError } from './gateway-authentication-error';
 export { GatewayFailedDependencyError } from './gateway-failed-dependency-error';
+export { GatewayForbiddenError } from './gateway-forbidden-error';
 export { GatewayInternalServerError } from './gateway-internal-server-error';
 export { GatewayInvalidRequestError } from './gateway-invalid-request-error';
 export {

package/src/gateway-embedding-model.ts

@@ -77,7 +77,7 @@ export class GatewayEmbeddingModel implements EmbeddingModelV3 {
         providerMetadata:
           responseBody.providerMetadata as unknown as SharedV3ProviderMetadata,
         response: { headers: responseHeaders, body: rawValue },
-        warnings: [],
+        warnings: responseBody.warnings ?? [],
       };
     } catch (error) {
       throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
@@ -96,11 +96,29 @@ export class GatewayEmbeddingModel implements EmbeddingModelV3 {
   }
 }
 
+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('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(),
       providerMetadata: z
         .record(z.string(), z.record(z.string(), z.unknown()))
         .optional(),

package/src/gateway-language-model-settings.ts

@@ -29,7 +29,6 @@ export type GatewayModelId =
   | 'amazon/nova-pro'
   | 'anthropic/claude-3-haiku'
   | 'anthropic/claude-3.5-haiku'
-  | 'anthropic/claude-fable-5'
   | 'anthropic/claude-haiku-4.5'
   | 'anthropic/claude-opus-4'
   | 'anthropic/claude-opus-4.1'
@@ -114,6 +113,7 @@ export type GatewayModelId =
   | 'moonshotai/kimi-k2.5'
   | 'moonshotai/kimi-k2.6'
   | 'moonshotai/kimi-k2.7-code'
+  | 'moonshotai/kimi-k2.7-code-highspeed'
   | 'morph/morph-v3-fast'
   | 'morph/morph-v3-large'
   | 'nvidia/nemotron-3-nano-30b-a3b'

package/src/gateway-reranking-model.ts

@@ -78,7 +78,7 @@ export class GatewayRerankingModel implements RerankingModelV3 {
         providerMetadata:
           responseBody.providerMetadata as unknown as SharedV3ProviderMetadata,
         response: { headers: responseHeaders, body: rawValue },
-        warnings: [],
+        warnings: responseBody.warnings ?? [],
       };
     } catch (error) {
       throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
@@ -97,6 +97,23 @@ export class GatewayRerankingModel implements RerankingModelV3 {
   }
 }
 
+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('other'),
+    message: z.string(),
+  }),
+]);
+
 const gatewayRerankingResponseSchema = lazySchema(() =>
   zodSchema(
     z.object({
@@ -106,6 +123,7 @@ const gatewayRerankingResponseSchema = lazySchema(() =>
           relevanceScore: z.number(),
         }),
       ),
+      warnings: z.array(gatewayRerankingWarningSchema).optional(),
       providerMetadata: z
         .record(z.string(), z.record(z.string(), z.unknown()))
         .optional(),

package/src/index.ts

@@ -34,6 +34,7 @@ export {
   GatewayError,
   GatewayAuthenticationError,
   GatewayFailedDependencyError,
+  GatewayForbiddenError,
   GatewayInvalidRequestError,
   GatewayRateLimitError,
   GatewayModelNotFoundError,