@ai-sdk/gateway 4.0.0-beta.4 → 4.0.0-beta.41

package/dist/index.mjs

@@ -536,7 +536,7 @@ var gatewayAvailableModelsResponseSchema = lazySchema4(
             })
           ).nullish(),
           specification: z4.object({
-            specificationVersion: z4.literal("v3"),
+            specificationVersion: z4.literal("v4"),
             provider: z4.string(),
             modelId: z4.string()
           }),
@@ -558,21 +558,224 @@ var gatewayCreditsResponseSchema = lazySchema4(
   )
 );
 
+// src/gateway-spend-report.ts
+import {
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  getFromApi as getFromApi2,
+  lazySchema as lazySchema5,
+  resolve as resolve2,
+  zodSchema as zodSchema5
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+var GatewaySpendReport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async getSpendReport(params) {
+    try {
+      const baseUrl = new URL(this.config.baseURL);
+      const searchParams = new URLSearchParams();
+      searchParams.set("start_date", params.startDate);
+      searchParams.set("end_date", params.endDate);
+      if (params.groupBy) {
+        searchParams.set("group_by", params.groupBy);
+      }
+      if (params.datePart) {
+        searchParams.set("date_part", params.datePart);
+      }
+      if (params.userId) {
+        searchParams.set("user_id", params.userId);
+      }
+      if (params.model) {
+        searchParams.set("model", params.model);
+      }
+      if (params.provider) {
+        searchParams.set("provider", params.provider);
+      }
+      if (params.credentialType) {
+        searchParams.set("credential_type", params.credentialType);
+      }
+      if (params.tags && params.tags.length > 0) {
+        searchParams.set("tags", params.tags.join(","));
+      }
+      const { value } = await getFromApi2({
+        url: `${baseUrl.origin}/v1/report?${searchParams.toString()}`,
+        headers: await resolve2(this.config.headers()),
+        successfulResponseHandler: createJsonResponseHandler2(
+          gatewaySpendReportResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler2({
+          errorSchema: z5.any(),
+          errorToMessage: (data) => data
+        }),
+        fetch: this.config.fetch
+      });
+      return value;
+    } catch (error) {
+      throw await asGatewayError(error);
+    }
+  }
+};
+var gatewaySpendReportResponseSchema = lazySchema5(
+  () => zodSchema5(
+    z5.object({
+      results: z5.array(
+        z5.object({
+          day: z5.string().optional(),
+          hour: z5.string().optional(),
+          user: z5.string().optional(),
+          model: z5.string().optional(),
+          tag: z5.string().optional(),
+          provider: z5.string().optional(),
+          credential_type: z5.enum(["byok", "system"]).optional(),
+          total_cost: z5.number(),
+          market_cost: z5.number().optional(),
+          input_tokens: z5.number().optional(),
+          output_tokens: z5.number().optional(),
+          cached_input_tokens: z5.number().optional(),
+          cache_creation_input_tokens: z5.number().optional(),
+          reasoning_tokens: z5.number().optional(),
+          request_count: z5.number().optional()
+        }).transform(
+          ({
+            credential_type,
+            total_cost,
+            market_cost,
+            input_tokens,
+            output_tokens,
+            cached_input_tokens,
+            cache_creation_input_tokens,
+            reasoning_tokens,
+            request_count,
+            ...rest
+          }) => ({
+            ...rest,
+            ...credential_type !== void 0 ? { credentialType: credential_type } : {},
+            totalCost: total_cost,
+            ...market_cost !== void 0 ? { marketCost: market_cost } : {},
+            ...input_tokens !== void 0 ? { inputTokens: input_tokens } : {},
+            ...output_tokens !== void 0 ? { outputTokens: output_tokens } : {},
+            ...cached_input_tokens !== void 0 ? { cachedInputTokens: cached_input_tokens } : {},
+            ...cache_creation_input_tokens !== void 0 ? { cacheCreationInputTokens: cache_creation_input_tokens } : {},
+            ...reasoning_tokens !== void 0 ? { reasoningTokens: reasoning_tokens } : {},
+            ...request_count !== void 0 ? { requestCount: request_count } : {}
+          })
+        )
+      )
+    })
+  )
+);
+
+// src/gateway-generation-info.ts
+import {
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  getFromApi as getFromApi3,
+  lazySchema as lazySchema6,
+  resolve as resolve3,
+  zodSchema as zodSchema6
+} from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var GatewayGenerationInfoFetcher = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async getGenerationInfo(params) {
+    try {
+      const baseUrl = new URL(this.config.baseURL);
+      const { value } = await getFromApi3({
+        url: `${baseUrl.origin}/v1/generation?id=${encodeURIComponent(params.id)}`,
+        headers: await resolve3(this.config.headers()),
+        successfulResponseHandler: createJsonResponseHandler3(
+          gatewayGenerationInfoResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler3({
+          errorSchema: z6.any(),
+          errorToMessage: (data) => data
+        }),
+        fetch: this.config.fetch
+      });
+      return value;
+    } catch (error) {
+      throw await asGatewayError(error);
+    }
+  }
+};
+var gatewayGenerationInfoResponseSchema = lazySchema6(
+  () => zodSchema6(
+    z6.object({
+      data: z6.object({
+        id: z6.string(),
+        total_cost: z6.number(),
+        upstream_inference_cost: z6.number(),
+        usage: z6.number(),
+        created_at: z6.string(),
+        model: z6.string(),
+        is_byok: z6.boolean(),
+        provider_name: z6.string(),
+        streamed: z6.boolean(),
+        finish_reason: z6.string(),
+        latency: z6.number(),
+        generation_time: z6.number(),
+        native_tokens_prompt: z6.number(),
+        native_tokens_completion: z6.number(),
+        native_tokens_reasoning: z6.number(),
+        native_tokens_cached: z6.number(),
+        native_tokens_cache_creation: z6.number(),
+        billable_web_search_calls: z6.number()
+      }).transform(
+        ({
+          total_cost,
+          upstream_inference_cost,
+          created_at,
+          is_byok,
+          provider_name,
+          finish_reason,
+          generation_time,
+          native_tokens_prompt,
+          native_tokens_completion,
+          native_tokens_reasoning,
+          native_tokens_cached,
+          native_tokens_cache_creation,
+          billable_web_search_calls,
+          ...rest
+        }) => ({
+          ...rest,
+          totalCost: total_cost,
+          upstreamInferenceCost: upstream_inference_cost,
+          createdAt: created_at,
+          isByok: is_byok,
+          providerName: provider_name,
+          finishReason: finish_reason,
+          generationTime: generation_time,
+          promptTokens: native_tokens_prompt,
+          completionTokens: native_tokens_completion,
+          reasoningTokens: native_tokens_reasoning,
+          cachedTokens: native_tokens_cached,
+          cacheCreationTokens: native_tokens_cache_creation,
+          billableWebSearchCalls: billable_web_search_calls
+        })
+      )
+    }).transform(({ data }) => data)
+  )
+);
+
 // src/gateway-language-model.ts
 import {
   combineHeaders,
   createEventSourceResponseHandler,
-  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
-  createJsonResponseHandler as createJsonResponseHandler2,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler4,
   postJsonToApi,
-  resolve as resolve2
+  resolve as resolve4
 } from "@ai-sdk/provider-utils";
-import { z as z5 } from "zod/v4";
+import { z as z7 } from "zod/v4";
 var GatewayLanguageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
     this.supportedUrls = { "*/*": [/.*/] };
   }
   get provider() {
@@ -588,7 +791,7 @@ var GatewayLanguageModel = class {
   async doGenerate(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await resolve2(this.config.headers());
+    const resolvedHeaders = await resolve4(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -600,12 +803,12 @@ var GatewayLanguageModel = class {
           resolvedHeaders,
           options.headers,
           this.getModelConfigHeaders(this.modelId, false),
-          await resolve2(this.config.o11yHeaders)
+          await resolve4(this.config.o11yHeaders)
         ),
         body: args,
-        successfulResponseHandler: createJsonResponseHandler2(z5.any()),
-        failedResponseHandler: createJsonErrorResponseHandler2({
-          errorSchema: z5.any(),
+        successfulResponseHandler: createJsonResponseHandler4(z7.any()),
+        failedResponseHandler: createJsonErrorResponseHandler4({
+          errorSchema: z7.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -624,7 +827,7 @@ var GatewayLanguageModel = class {
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await resolve2(this.config.headers());
+    const resolvedHeaders = await resolve4(this.config.headers());
     try {
       const { value: response, responseHeaders } = await postJsonToApi({
         url: this.getUrl(),
@@ -632,12 +835,12 @@ var GatewayLanguageModel = class {
           resolvedHeaders,
           options.headers,
           this.getModelConfigHeaders(this.modelId, true),
-          await resolve2(this.config.o11yHeaders)
+          await resolve4(this.config.o11yHeaders)
         ),
         body: args,
-        successfulResponseHandler: createEventSourceResponseHandler(z5.any()),
-        failedResponseHandler: createJsonErrorResponseHandler2({
-          errorSchema: z5.any(),
+        successfulResponseHandler: createEventSourceResponseHandler(z7.any()),
+        failedResponseHandler: createJsonErrorResponseHandler4({
+          errorSchema: z7.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -707,7 +910,7 @@ var GatewayLanguageModel = class {
   }
   getModelConfigHeaders(modelId, streaming) {
     return {
-      "ai-language-model-specification-version": "3",
+      "ai-language-model-specification-version": "4",
       "ai-language-model-id": modelId,
       "ai-language-model-streaming": String(streaming)
     };
@@ -717,19 +920,19 @@ var GatewayLanguageModel = class {
 // src/gateway-embedding-model.ts
 import {
   combineHeaders as combineHeaders2,
-  createJsonErrorResponseHandler as createJsonErrorResponseHandler3,
-  createJsonResponseHandler as createJsonResponseHandler3,
-  lazySchema as lazySchema5,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler5,
+  createJsonResponseHandler as createJsonResponseHandler5,
+  lazySchema as lazySchema7,
   postJsonToApi as postJsonToApi2,
-  resolve as resolve3,
-  zodSchema as zodSchema5
+  resolve as resolve5,
+  zodSchema as zodSchema7
 } from "@ai-sdk/provider-utils";
-import { z as z6 } from "zod/v4";
+import { z as z8 } from "zod/v4";
 var GatewayEmbeddingModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
     this.maxEmbeddingsPerCall = 2048;
     this.supportsParallelCalls = true;
   }
@@ -743,7 +946,7 @@ var GatewayEmbeddingModel = class {
     providerOptions
   }) {
     var _a9;
-    const resolvedHeaders = await resolve3(this.config.headers());
+    const resolvedHeaders = await resolve5(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -755,17 +958,17 @@ var GatewayEmbeddingModel = class {
           resolvedHeaders,
           headers != null ? headers : {},
           this.getModelConfigHeaders(),
-          await resolve3(this.config.o11yHeaders)
+          await resolve5(this.config.o11yHeaders)
         ),
         body: {
           values,
           ...providerOptions ? { providerOptions } : {}
         },
-        successfulResponseHandler: createJsonResponseHandler3(
+        successfulResponseHandler: createJsonResponseHandler5(
           gatewayEmbeddingResponseSchema
         ),
-        failedResponseHandler: createJsonErrorResponseHandler3({
-          errorSchema: z6.any(),
+        failedResponseHandler: createJsonErrorResponseHandler5({
+          errorSchema: z8.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -787,17 +990,17 @@ var GatewayEmbeddingModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-embedding-model-specification-version": "3",
+      "ai-embedding-model-specification-version": "4",
       "ai-model-id": this.modelId
     };
   }
 };
-var gatewayEmbeddingResponseSchema = lazySchema5(
-  () => zodSchema5(
-    z6.object({
-      embeddings: z6.array(z6.array(z6.number())),
-      usage: z6.object({ tokens: z6.number() }).nullish(),
-      providerMetadata: z6.record(z6.string(), z6.record(z6.string(), z6.unknown())).optional()
+var gatewayEmbeddingResponseSchema = lazySchema7(
+  () => zodSchema7(
+    z8.object({
+      embeddings: z8.array(z8.array(z8.number())),
+      usage: z8.object({ tokens: z8.number() }).nullish(),
+      providerMetadata: z8.record(z8.string(), z8.record(z8.string(), z8.unknown())).optional()
     })
   )
 );
@@ -806,17 +1009,17 @@ var gatewayEmbeddingResponseSchema = lazySchema5(
 import {
   combineHeaders as combineHeaders3,
   convertUint8ArrayToBase64,
-  createJsonResponseHandler as createJsonResponseHandler4,
-  createJsonErrorResponseHandler as createJsonErrorResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler6,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler6,
   postJsonToApi as postJsonToApi3,
-  resolve as resolve4
+  resolve as resolve6
 } from "@ai-sdk/provider-utils";
-import { z as z7 } from "zod/v4";
+import { z as z9 } from "zod/v4";
 var GatewayImageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
     // Set a very large number to prevent client-side splitting of requests
     this.maxImagesPerCall = Number.MAX_SAFE_INTEGER;
   }
@@ -836,7 +1039,7 @@ var GatewayImageModel = class {
     abortSignal
   }) {
     var _a9, _b9, _c, _d;
-    const resolvedHeaders = await resolve4(this.config.headers());
+    const resolvedHeaders = await resolve6(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -848,7 +1051,7 @@ var GatewayImageModel = class {
           resolvedHeaders,
           headers != null ? headers : {},
           this.getModelConfigHeaders(),
-          await resolve4(this.config.o11yHeaders)
+          await resolve6(this.config.o11yHeaders)
         ),
         body: {
           prompt,
@@ -862,11 +1065,11 @@ var GatewayImageModel = class {
           },
           ...mask && { mask: maybeEncodeImageFile(mask) }
         },
-        successfulResponseHandler: createJsonResponseHandler4(
+        successfulResponseHandler: createJsonResponseHandler6(
           gatewayImageResponseSchema
         ),
-        failedResponseHandler: createJsonErrorResponseHandler4({
-          errorSchema: z7.any(),
+        failedResponseHandler: createJsonErrorResponseHandler6({
+          errorSchema: z9.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -899,7 +1102,7 @@ var GatewayImageModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-image-model-specification-version": "3",
+      "ai-image-model-specification-version": "4",
       "ai-model-id": this.modelId
     };
   }
@@ -913,35 +1116,35 @@ function maybeEncodeImageFile(file) {
   }
   return file;
 }
-var providerMetadataEntrySchema = z7.object({
-  images: z7.array(z7.unknown()).optional()
-}).catchall(z7.unknown());
-var gatewayImageWarningSchema = z7.discriminatedUnion("type", [
-  z7.object({
-    type: z7.literal("unsupported"),
-    feature: z7.string(),
-    details: z7.string().optional()
+var providerMetadataEntrySchema = z9.object({
+  images: z9.array(z9.unknown()).optional()
+}).catchall(z9.unknown());
+var gatewayImageWarningSchema = z9.discriminatedUnion("type", [
+  z9.object({
+    type: z9.literal("unsupported"),
+    feature: z9.string(),
+    details: z9.string().optional()
   }),
-  z7.object({
-    type: z7.literal("compatibility"),
-    feature: z7.string(),
-    details: z7.string().optional()
+  z9.object({
+    type: z9.literal("compatibility"),
+    feature: z9.string(),
+    details: z9.string().optional()
   }),
-  z7.object({
-    type: z7.literal("other"),
-    message: z7.string()
+  z9.object({
+    type: z9.literal("other"),
+    message: z9.string()
   })
 ]);
-var gatewayImageUsageSchema = z7.object({
-  inputTokens: z7.number().nullish(),
-  outputTokens: z7.number().nullish(),
-  totalTokens: z7.number().nullish()
+var gatewayImageUsageSchema = z9.object({
+  inputTokens: z9.number().nullish(),
+  outputTokens: z9.number().nullish(),
+  totalTokens: z9.number().nullish()
 });
-var gatewayImageResponseSchema = z7.object({
-  images: z7.array(z7.string()),
+var gatewayImageResponseSchema = z9.object({
+  images: z9.array(z9.string()),
   // Always base64 strings over the wire
-  warnings: z7.array(gatewayImageWarningSchema).optional(),
-  providerMetadata: z7.record(z7.string(), providerMetadataEntrySchema).optional(),
+  warnings: z9.array(gatewayImageWarningSchema).optional(),
+  providerMetadata: z9.record(z9.string(), providerMetadataEntrySchema).optional(),
   usage: gatewayImageUsageSchema.optional()
 });
 
@@ -950,17 +1153,17 @@ import { APICallError as APICallError2 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders4,
   convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
-  createJsonErrorResponseHandler as createJsonErrorResponseHandler5,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler7,
   parseJsonEventStream,
   postJsonToApi as postJsonToApi4,
-  resolve as resolve5
+  resolve as resolve7
 } from "@ai-sdk/provider-utils";
-import { z as z8 } from "zod/v4";
+import { z as z10 } from "zod/v4";
 var GatewayVideoModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
     // Set a very large number to prevent client-side splitting of requests
     this.maxVideosPerCall = Number.MAX_SAFE_INTEGER;
   }
@@ -981,7 +1184,7 @@ var GatewayVideoModel = class {
     abortSignal
   }) {
     var _a9;
-    const resolvedHeaders = await resolve5(this.config.headers());
+    const resolvedHeaders = await resolve7(this.config.headers());
     try {
       const { responseHeaders, value: responseBody } = await postJsonToApi4({
         url: this.getUrl(),
@@ -989,7 +1192,7 @@ var GatewayVideoModel = class {
           resolvedHeaders,
           headers != null ? headers : {},
           this.getModelConfigHeaders(),
-          await resolve5(this.config.o11yHeaders),
+          await resolve7(this.config.o11yHeaders),
           { accept: "text/event-stream" }
         ),
         body: {
@@ -1067,8 +1270,8 @@ var GatewayVideoModel = class {
             responseHeaders: Object.fromEntries([...response.headers])
           };
         },
-        failedResponseHandler: createJsonErrorResponseHandler5({
-          errorSchema: z8.any(),
+        failedResponseHandler: createJsonErrorResponseHandler7({
+          errorSchema: z10.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -1093,7 +1296,7 @@ var GatewayVideoModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-video-model-specification-version": "3",
+      "ai-video-model-specification-version": "4",
       "ai-model-id": this.modelId
     };
   }
@@ -1107,115 +1310,207 @@ function maybeEncodeVideoFile(file) {
   }
   return file;
 }
-var providerMetadataEntrySchema2 = z8.object({
-  videos: z8.array(z8.unknown()).optional()
-}).catchall(z8.unknown());
-var gatewayVideoDataSchema = z8.union([
-  z8.object({
-    type: z8.literal("url"),
-    url: z8.string(),
-    mediaType: z8.string()
+var providerMetadataEntrySchema2 = z10.object({
+  videos: z10.array(z10.unknown()).optional()
+}).catchall(z10.unknown());
+var gatewayVideoDataSchema = z10.union([
+  z10.object({
+    type: z10.literal("url"),
+    url: z10.string(),
+    mediaType: z10.string()
   }),
-  z8.object({
-    type: z8.literal("base64"),
-    data: z8.string(),
-    mediaType: z8.string()
+  z10.object({
+    type: z10.literal("base64"),
+    data: z10.string(),
+    mediaType: z10.string()
   })
 ]);
-var gatewayVideoWarningSchema = z8.discriminatedUnion("type", [
-  z8.object({
-    type: z8.literal("unsupported"),
-    feature: z8.string(),
-    details: z8.string().optional()
+var gatewayVideoWarningSchema = z10.discriminatedUnion("type", [
+  z10.object({
+    type: z10.literal("unsupported"),
+    feature: z10.string(),
+    details: z10.string().optional()
   }),
-  z8.object({
-    type: z8.literal("compatibility"),
-    feature: z8.string(),
-    details: z8.string().optional()
+  z10.object({
+    type: z10.literal("compatibility"),
+    feature: z10.string(),
+    details: z10.string().optional()
   }),
-  z8.object({
-    type: z8.literal("other"),
-    message: z8.string()
+  z10.object({
+    type: z10.literal("other"),
+    message: z10.string()
   })
 ]);
-var gatewayVideoEventSchema = z8.discriminatedUnion("type", [
-  z8.object({
-    type: z8.literal("result"),
-    videos: z8.array(gatewayVideoDataSchema),
-    warnings: z8.array(gatewayVideoWarningSchema).optional(),
-    providerMetadata: z8.record(z8.string(), providerMetadataEntrySchema2).optional()
+var gatewayVideoEventSchema = z10.discriminatedUnion("type", [
+  z10.object({
+    type: z10.literal("result"),
+    videos: z10.array(gatewayVideoDataSchema),
+    warnings: z10.array(gatewayVideoWarningSchema).optional(),
+    providerMetadata: z10.record(z10.string(), providerMetadataEntrySchema2).optional()
   }),
-  z8.object({
-    type: z8.literal("error"),
-    message: z8.string(),
-    errorType: z8.string(),
-    statusCode: z8.number(),
-    param: z8.unknown().nullable()
+  z10.object({
+    type: z10.literal("error"),
+    message: z10.string(),
+    errorType: z10.string(),
+    statusCode: z10.number(),
+    param: z10.unknown().nullable()
   })
 ]);
 
+// src/gateway-reranking-model.ts
+import {
+  combineHeaders as combineHeaders5,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler8,
+  createJsonResponseHandler as createJsonResponseHandler7,
+  lazySchema as lazySchema8,
+  postJsonToApi as postJsonToApi5,
+  resolve as resolve8,
+  zodSchema as zodSchema8
+} from "@ai-sdk/provider-utils";
+import { z as z11 } from "zod/v4";
+var GatewayRerankingModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doRerank({
+    documents,
+    query,
+    topN,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    const resolvedHeaders = await resolve8(this.config.headers());
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue
+      } = await postJsonToApi5({
+        url: this.getUrl(),
+        headers: combineHeaders5(
+          resolvedHeaders,
+          headers != null ? headers : {},
+          this.getModelConfigHeaders(),
+          await resolve8(this.config.o11yHeaders)
+        ),
+        body: {
+          documents,
+          query,
+          ...topN != null ? { topN } : {},
+          ...providerOptions ? { providerOptions } : {}
+        },
+        successfulResponseHandler: createJsonResponseHandler7(
+          gatewayRerankingResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler8({
+          errorSchema: z11.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        ranking: responseBody.ranking,
+        providerMetadata: responseBody.providerMetadata,
+        response: { headers: responseHeaders, body: rawValue },
+        warnings: []
+      };
+    } catch (error) {
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+  getUrl() {
+    return `${this.config.baseURL}/reranking-model`;
+  }
+  getModelConfigHeaders() {
+    return {
+      "ai-reranking-model-specification-version": "4",
+      "ai-model-id": this.modelId
+    };
+  }
+};
+var gatewayRerankingResponseSchema = lazySchema8(
+  () => zodSchema8(
+    z11.object({
+      ranking: z11.array(
+        z11.object({
+          index: z11.number(),
+          relevanceScore: z11.number()
+        })
+      ),
+      providerMetadata: z11.record(z11.string(), z11.record(z11.string(), z11.unknown())).optional()
+    })
+  )
+);
+
 // src/tool/parallel-search.ts
 import {
   createProviderToolFactoryWithOutputSchema,
-  lazySchema as lazySchema6,
-  zodSchema as zodSchema6
+  lazySchema as lazySchema9,
+  zodSchema as zodSchema9
 } from "@ai-sdk/provider-utils";
-import { z as z9 } from "zod";
-var parallelSearchInputSchema = lazySchema6(
-  () => zodSchema6(
-    z9.object({
-      objective: z9.string().describe(
+import { z as z12 } from "zod";
+var parallelSearchInputSchema = lazySchema9(
+  () => zodSchema9(
+    z12.object({
+      objective: z12.string().describe(
         "Natural-language description of the web research goal, including source or freshness guidance and broader context from the task. Maximum 5000 characters."
       ),
-      search_queries: z9.array(z9.string()).optional().describe(
+      search_queries: z12.array(z12.string()).optional().describe(
         "Optional search queries to supplement the objective. Maximum 200 characters per query."
       ),
-      mode: z9.enum(["one-shot", "agentic"]).optional().describe(
+      mode: z12.enum(["one-shot", "agentic"]).optional().describe(
         'Mode preset: "one-shot" for comprehensive results with longer excerpts (default), "agentic" for concise, token-efficient results for multi-step workflows.'
       ),
-      max_results: z9.number().optional().describe(
+      max_results: z12.number().optional().describe(
         "Maximum number of results to return (1-20). Defaults to 10 if not specified."
       ),
-      source_policy: z9.object({
-        include_domains: z9.array(z9.string()).optional().describe("List of domains to include in search results."),
-        exclude_domains: z9.array(z9.string()).optional().describe("List of domains to exclude from search results."),
-        after_date: z9.string().optional().describe(
+      source_policy: z12.object({
+        include_domains: z12.array(z12.string()).optional().describe("List of domains to include in search results."),
+        exclude_domains: z12.array(z12.string()).optional().describe("List of domains to exclude from search results."),
+        after_date: z12.string().optional().describe(
           "Only include results published after this date (ISO 8601 format)."
         )
       }).optional().describe(
         "Source policy for controlling which domains to include/exclude and freshness."
       ),
-      excerpts: z9.object({
-        max_chars_per_result: z9.number().optional().describe("Maximum characters per result."),
-        max_chars_total: z9.number().optional().describe("Maximum total characters across all results.")
+      excerpts: z12.object({
+        max_chars_per_result: z12.number().optional().describe("Maximum characters per result."),
+        max_chars_total: z12.number().optional().describe("Maximum total characters across all results.")
       }).optional().describe("Excerpt configuration for controlling result length."),
-      fetch_policy: z9.object({
-        max_age_seconds: z9.number().optional().describe(
+      fetch_policy: z12.object({
+        max_age_seconds: z12.number().optional().describe(
           "Maximum age in seconds for cached content. Set to 0 to always fetch fresh content."
         )
       }).optional().describe("Fetch policy for controlling content freshness.")
     })
   )
 );
-var parallelSearchOutputSchema = lazySchema6(
-  () => zodSchema6(
-    z9.union([
+var parallelSearchOutputSchema = lazySchema9(
+  () => zodSchema9(
+    z12.union([
       // Success response
-      z9.object({
-        searchId: z9.string(),
-        results: z9.array(
-          z9.object({
-            url: z9.string(),
-            title: z9.string(),
-            excerpt: z9.string(),
-            publishDate: z9.string().nullable().optional(),
-            relevanceScore: z9.number().optional()
+      z12.object({
+        searchId: z12.string(),
+        results: z12.array(
+          z12.object({
+            url: z12.string(),
+            title: z12.string(),
+            excerpt: z12.string(),
+            publishDate: z12.string().nullable().optional(),
+            relevanceScore: z12.number().optional()
           })
         )
       }),
       // Error response
-      z9.object({
-        error: z9.enum([
+      z12.object({
+        error: z12.enum([
           "api_error",
           "rate_limit",
           "timeout",
@@ -1223,8 +1518,8 @@ var parallelSearchOutputSchema = lazySchema6(
           "configuration_error",
           "unknown"
         ]),
-        statusCode: z9.number().optional(),
-        message: z9.string()
+        statusCode: z12.number().optional(),
+        message: z12.string()
       })
     ])
   )
@@ -1239,79 +1534,79 @@ var parallelSearch = (config = {}) => parallelSearchToolFactory(config);
 // src/tool/perplexity-search.ts
 import {
   createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema2,
-  lazySchema as lazySchema7,
-  zodSchema as zodSchema7
+  lazySchema as lazySchema10,
+  zodSchema as zodSchema10
 } from "@ai-sdk/provider-utils";
-import { z as z10 } from "zod";
-var perplexitySearchInputSchema = lazySchema7(
-  () => zodSchema7(
-    z10.object({
-      query: z10.union([z10.string(), z10.array(z10.string())]).describe(
+import { z as z13 } from "zod";
+var perplexitySearchInputSchema = lazySchema10(
+  () => zodSchema10(
+    z13.object({
+      query: z13.union([z13.string(), z13.array(z13.string())]).describe(
         "Search query (string) or multiple queries (array of up to 5 strings). Multi-query searches return combined results from all queries."
       ),
-      max_results: z10.number().optional().describe(
+      max_results: z13.number().optional().describe(
         "Maximum number of search results to return (1-20, default: 10)"
       ),
-      max_tokens_per_page: z10.number().optional().describe(
+      max_tokens_per_page: z13.number().optional().describe(
         "Maximum number of tokens to extract per search result page (256-2048, default: 2048)"
       ),
-      max_tokens: z10.number().optional().describe(
+      max_tokens: z13.number().optional().describe(
         "Maximum total tokens across all search results (default: 25000, max: 1000000)"
       ),
-      country: z10.string().optional().describe(
+      country: z13.string().optional().describe(
         "Two-letter ISO 3166-1 alpha-2 country code for regional search results (e.g., 'US', 'GB', 'FR')"
       ),
-      search_domain_filter: z10.array(z10.string()).optional().describe(
+      search_domain_filter: z13.array(z13.string()).optional().describe(
         "List of domains to include or exclude from search results (max 20). To include: ['nature.com', 'science.org']. To exclude: ['-example.com', '-spam.net']"
       ),
-      search_language_filter: z10.array(z10.string()).optional().describe(
+      search_language_filter: z13.array(z13.string()).optional().describe(
         "List of ISO 639-1 language codes to filter results (max 10, lowercase). Examples: ['en', 'fr', 'de']"
       ),
-      search_after_date: z10.string().optional().describe(
+      search_after_date: z13.string().optional().describe(
         "Include only results published after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
       ),
-      search_before_date: z10.string().optional().describe(
+      search_before_date: z13.string().optional().describe(
         "Include only results published before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
       ),
-      last_updated_after_filter: z10.string().optional().describe(
+      last_updated_after_filter: z13.string().optional().describe(
         "Include only results last updated after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
       ),
-      last_updated_before_filter: z10.string().optional().describe(
+      last_updated_before_filter: z13.string().optional().describe(
         "Include only results last updated before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
       ),
-      search_recency_filter: z10.enum(["day", "week", "month", "year"]).optional().describe(
+      search_recency_filter: z13.enum(["day", "week", "month", "year"]).optional().describe(
         "Filter results by relative time period. Cannot be used with search_after_date or search_before_date."
       )
     })
   )
 );
-var perplexitySearchOutputSchema = lazySchema7(
-  () => zodSchema7(
-    z10.union([
+var perplexitySearchOutputSchema = lazySchema10(
+  () => zodSchema10(
+    z13.union([
       // Success response
-      z10.object({
-        results: z10.array(
-          z10.object({
-            title: z10.string(),
-            url: z10.string(),
-            snippet: z10.string(),
-            date: z10.string().optional(),
-            lastUpdated: z10.string().optional()
+      z13.object({
+        results: z13.array(
+          z13.object({
+            title: z13.string(),
+            url: z13.string(),
+            snippet: z13.string(),
+            date: z13.string().optional(),
+            lastUpdated: z13.string().optional()
           })
         ),
-        id: z10.string()
+        id: z13.string()
       }),
       // Error response
-      z10.object({
-        error: z10.enum([
+      z13.object({
+        error: z13.enum([
           "api_error",
           "rate_limit",
           "timeout",
           "invalid_input",
           "unknown"
         ]),
-        statusCode: z10.number().optional(),
-        message: z10.string()
+        statusCode: z13.number().optional(),
+        message: z13.string()
       })
     ])
   )
@@ -1356,7 +1651,7 @@ async function getVercelRequestId() {
 import { withUserAgentSuffix } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "4.0.0-beta.4" : "0.0.0-test";
+var VERSION = true ? "4.0.0-beta.41" : "0.0.0-test";
 
 // src/gateway-provider.ts
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
@@ -1458,6 +1753,30 @@ function createGatewayProvider(options = {}) {
       );
     });
   };
+  const getSpendReport = async (params) => {
+    return new GatewaySpendReport({
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch
+    }).getSpendReport(params).catch(async (error) => {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(await getHeaders())
+      );
+    });
+  };
+  const getGenerationInfo = async (params) => {
+    return new GatewayGenerationInfoFetcher({
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch
+    }).getGenerationInfo(params).catch(async (error) => {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(await getHeaders())
+      );
+    });
+  };
   const provider = function(modelId) {
     if (new.target) {
       throw new Error(
@@ -1466,9 +1785,11 @@ function createGatewayProvider(options = {}) {
     }
     return createLanguageModel(modelId);
   };
-  provider.specificationVersion = "v3";
+  provider.specificationVersion = "v4";
   provider.getAvailableModels = getAvailableModels;
   provider.getCredits = getCredits;
+  provider.getSpendReport = getSpendReport;
+  provider.getGenerationInfo = getGenerationInfo;
   provider.imageModel = (modelId) => {
     return new GatewayImageModel(modelId, {
       provider: "gateway",
@@ -1499,6 +1820,17 @@ function createGatewayProvider(options = {}) {
       o11yHeaders: createO11yHeaders()
     });
   };
+  const createRerankingModel = (modelId) => {
+    return new GatewayRerankingModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
+  };
+  provider.rerankingModel = createRerankingModel;
+  provider.reranking = createRerankingModel;
   provider.chat = provider.languageModel;
   provider.embedding = provider.embeddingModel;
   provider.image = provider.imageModel;