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

package/src/gateway-spend-report.ts

@@ -0,0 +1,193 @@
+import {
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  getFromApi,
+  lazySchema,
+  resolve,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { asGatewayError } from './errors';
+import type { GatewayConfig } from './gateway-config';
+
+export interface GatewaySpendReportParams {
+  /** Start date in YYYY-MM-DD format (inclusive) */
+  startDate: string;
+  /** End date in YYYY-MM-DD format (inclusive) */
+  endDate: string;
+  /** Primary aggregation dimension. Defaults to 'day'. */
+  groupBy?: 'day' | 'user' | 'model' | 'tag' | 'provider' | 'credential_type';
+  /** Time granularity when groupBy is 'day'. */
+  datePart?: 'day' | 'hour';
+  /** Filter to a specific user's spend. */
+  userId?: string;
+  /** Filter to a specific model (e.g. 'anthropic/claude-sonnet-4.5'). */
+  model?: string;
+  /** Filter to a specific provider (e.g. 'anthropic'). */
+  provider?: string;
+  /** Filter to BYOK or system credentials. */
+  credentialType?: 'byok' | 'system';
+  /** Filter to requests with these tags. */
+  tags?: string[];
+}
+
+export interface GatewaySpendReportRow {
+  /** Date string (present when groupBy is 'day') */
+  day?: string;
+  /** Hour timestamp (present when groupBy is 'day' and datePart is 'hour') */
+  hour?: string;
+  /** User identifier (present when groupBy is 'user') */
+  user?: string;
+  /** Model identifier (present when groupBy is 'model') */
+  model?: string;
+  /** Tag value (present when groupBy is 'tag') */
+  tag?: string;
+  /** Provider name (present when groupBy is 'provider') */
+  provider?: string;
+  /** Credential type (present when groupBy is 'credential_type') */
+  credentialType?: 'byok' | 'system';
+
+  /** Total cost in USD */
+  totalCost: number;
+  /** Market cost in USD */
+  marketCost?: number;
+  /** Number of input tokens */
+  inputTokens?: number;
+  /** Number of output tokens */
+  outputTokens?: number;
+  /** Number of cached input tokens */
+  cachedInputTokens?: number;
+  /** Number of cache creation input tokens */
+  cacheCreationInputTokens?: number;
+  /** Number of reasoning tokens */
+  reasoningTokens?: number;
+  /** Number of requests */
+  requestCount?: number;
+}
+
+export interface GatewaySpendReportResponse {
+  results: GatewaySpendReportRow[];
+}
+
+export class GatewaySpendReport {
+  constructor(private readonly config: GatewayConfig) {}
+
+  async getSpendReport(
+    params: GatewaySpendReportParams,
+  ): Promise<GatewaySpendReportResponse> {
+    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 getFromApi({
+        url: `${baseUrl.origin}/v1/report?${searchParams.toString()}`,
+        headers: this.config.headers
+          ? await resolve(this.config.headers)
+          : undefined,
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewaySpendReportResponseSchema,
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        fetch: this.config.fetch,
+      });
+
+      return value;
+    } catch (error) {
+      throw await asGatewayError(error);
+    }
+  }
+}
+
+const gatewaySpendReportResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      results: z.array(
+        z
+          .object({
+            day: z.string().optional(),
+            hour: z.string().optional(),
+            user: z.string().optional(),
+            model: z.string().optional(),
+            tag: z.string().optional(),
+            provider: z.string().optional(),
+            credential_type: z.enum(['byok', 'system']).optional(),
+            total_cost: z.number(),
+            market_cost: z.number().optional(),
+            input_tokens: z.number().optional(),
+            output_tokens: z.number().optional(),
+            cached_input_tokens: z.number().optional(),
+            cache_creation_input_tokens: z.number().optional(),
+            reasoning_tokens: z.number().optional(),
+            request_count: z.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 !== undefined
+                ? { credentialType: credential_type }
+                : {}),
+              totalCost: total_cost,
+              ...(market_cost !== undefined ? { marketCost: market_cost } : {}),
+              ...(input_tokens !== undefined
+                ? { inputTokens: input_tokens }
+                : {}),
+              ...(output_tokens !== undefined
+                ? { outputTokens: output_tokens }
+                : {}),
+              ...(cached_input_tokens !== undefined
+                ? { cachedInputTokens: cached_input_tokens }
+                : {}),
+              ...(cache_creation_input_tokens !== undefined
+                ? { cacheCreationInputTokens: cache_creation_input_tokens }
+                : {}),
+              ...(reasoning_tokens !== undefined
+                ? { reasoningTokens: reasoning_tokens }
+                : {}),
+              ...(request_count !== undefined
+                ? { requestCount: request_count }
+                : {}),
+            }),
+          ),
+      ),
+    }),
+  ),
+);

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

@@ -0,0 +1 @@
+export type GatewayTranscriptionModelId = string & {};

package/src/gateway-transcription-model.ts

@@ -0,0 +1,155 @@
+import type {
+  SharedV4ProviderMetadata,
+  SharedV4Warning,
+  TranscriptionModelV4,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertUint8ArrayToBase64,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  postJsonToApi,
+  resolve,
+  type Resolvable,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { asGatewayError } from './errors';
+import { parseAuthMethod } from './errors/parse-auth-method';
+import type { GatewayConfig } from './gateway-config';
+
+export class GatewayTranscriptionModel implements TranscriptionModelV4 {
+  readonly specificationVersion = 'v4' as const;
+
+  constructor(
+    readonly modelId: string,
+    private readonly config: GatewayConfig & {
+      provider: string;
+      o11yHeaders: Resolvable<Record<string, string>>;
+    },
+  ) {}
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  async doGenerate({
+    audio,
+    mediaType,
+    providerOptions,
+    headers,
+    abortSignal,
+  }: Parameters<TranscriptionModelV4['doGenerate']>[0]): Promise<
+    Awaited<ReturnType<TranscriptionModelV4['doGenerate']>>
+  > {
+    const resolvedHeaders = this.config.headers
+      ? await resolve(this.config.headers)
+      : undefined;
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue,
+      } = await postJsonToApi({
+        url: this.getUrl(),
+        headers: combineHeaders(
+          resolvedHeaders,
+          headers ?? {},
+          this.getModelConfigHeaders(),
+          await resolve(this.config.o11yHeaders),
+        ),
+        body: {
+          audio:
+            audio instanceof Uint8Array
+              ? convertUint8ArrayToBase64(audio)
+              : audio,
+          mediaType,
+          ...(providerOptions && { providerOptions }),
+        },
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayTranscriptionResponseSchema,
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        ...(abortSignal && { abortSignal }),
+        fetch: this.config.fetch,
+      });
+
+      return {
+        text: responseBody.text,
+        segments: responseBody.segments ?? [],
+        language: responseBody.language ?? undefined,
+        durationInSeconds: responseBody.durationInSeconds ?? undefined,
+        warnings: (responseBody.warnings ?? []) as Array<SharedV4Warning>,
+        providerMetadata:
+          responseBody.providerMetadata as SharedV4ProviderMetadata,
+        response: {
+          timestamp: new Date(),
+          modelId: this.modelId,
+          headers: responseHeaders,
+          body: rawValue,
+        },
+      };
+    } catch (error) {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders ?? {}),
+      );
+    }
+  }
+
+  private getUrl() {
+    return `${this.config.baseURL}/transcription-model`;
+  }
+
+  private getModelConfigHeaders() {
+    return {
+      'ai-transcription-model-specification-version': '4',
+      'ai-model-id': this.modelId,
+    };
+  }
+}
+
+const providerMetadataEntrySchema = z.object({}).catchall(z.unknown());
+
+const gatewayTranscriptionWarningSchema = 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 gatewayTranscriptionResponseSchema = z.object({
+  text: z.string(),
+  segments: z
+    .array(
+      z.object({
+        text: z.string(),
+        startSecond: z.number(),
+        endSecond: z.number(),
+      }),
+    )
+    .optional(),
+  language: z.string().nullish(),
+  durationInSeconds: z.number().nullish(),
+  warnings: z.array(gatewayTranscriptionWarningSchema).optional(),
+  providerMetadata: z
+    .record(z.string(), providerMetadataEntrySchema)
+    .optional(),
+});

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

@@ -5,6 +5,8 @@ export type GatewayVideoModelId =
   | 'alibaba/wan-v2.6-r2v'
   | 'alibaba/wan-v2.6-r2v-flash'
   | 'alibaba/wan-v2.6-t2v'
+  | 'bytedance/seedance-2.0'
+  | 'bytedance/seedance-2.0-fast'
   | 'bytedance/seedance-v1.0-lite-i2v'
   | 'bytedance/seedance-v1.0-lite-t2v'
   | 'bytedance/seedance-v1.0-pro'
@@ -20,6 +22,8 @@ export type GatewayVideoModelId =
   | 'klingai/kling-v2.6-motion-control'
   | 'klingai/kling-v2.6-t2v'
   | 'klingai/kling-v3.0-i2v'
+  | 'klingai/kling-v3.0-motion-control'
   | 'klingai/kling-v3.0-t2v'
   | 'xai/grok-imagine-video'
+  | 'xai/grok-imagine-video-1.5-preview'
   | (string & {});

package/src/gateway-video-model.ts

@@ -1,12 +1,12 @@
-import type {
-  Experimental_VideoModelV3,
-  Experimental_VideoModelV3CallOptions,
-  Experimental_VideoModelV3File,
-  Experimental_VideoModelV3VideoData,
-  SharedV3ProviderMetadata,
-  SharedV3Warning,
+import {
+  APICallError,
+  type Experimental_VideoModelV4,
+  type Experimental_VideoModelV4CallOptions,
+  type Experimental_VideoModelV4File,
+  type Experimental_VideoModelV4VideoData,
+  type SharedV4ProviderMetadata,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
-import { APICallError } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertUint8ArrayToBase64,
@@ -21,8 +21,8 @@ import type { GatewayConfig } from './gateway-config';
 import { asGatewayError } from './errors';
 import { parseAuthMethod } from './errors/parse-auth-method';
 
-export class GatewayVideoModel implements Experimental_VideoModelV3 {
-  readonly specificationVersion = 'v3' as const;
+export class GatewayVideoModel implements Experimental_VideoModelV4 {
+  readonly specificationVersion = 'v4' as const;
   // Set a very large number to prevent client-side splitting of requests
   readonly maxVideosPerCall = Number.MAX_SAFE_INTEGER;
 
@@ -50,17 +50,19 @@ export class GatewayVideoModel implements Experimental_VideoModelV3 {
     providerOptions,
     headers,
     abortSignal,
-  }: Experimental_VideoModelV3CallOptions): Promise<{
-    videos: Array<Experimental_VideoModelV3VideoData>;
-    warnings: Array<SharedV3Warning>;
-    providerMetadata?: SharedV3ProviderMetadata;
+  }: Experimental_VideoModelV4CallOptions): Promise<{
+    videos: Array<Experimental_VideoModelV4VideoData>;
+    warnings: Array<SharedV4Warning>;
+    providerMetadata?: SharedV4ProviderMetadata;
     response: {
       timestamp: Date;
       modelId: string;
       headers: Record<string, string> | undefined;
     };
   }> {
-    const resolvedHeaders = await resolve(this.config.headers());
+    const resolvedHeaders = this.config.headers
+      ? await resolve(this.config.headers)
+      : undefined;
     try {
       const { responseHeaders, value: responseBody } = await postJsonToApi({
         url: this.getUrl(),
@@ -170,7 +172,7 @@ export class GatewayVideoModel implements Experimental_VideoModelV3 {
         videos: responseBody.videos,
         warnings: responseBody.warnings ?? [],
         providerMetadata:
-          responseBody.providerMetadata as SharedV3ProviderMetadata,
+          responseBody.providerMetadata as SharedV4ProviderMetadata,
         response: {
           timestamp: new Date(),
           modelId: this.modelId,
@@ -178,7 +180,10 @@ export class GatewayVideoModel implements Experimental_VideoModelV3 {
         },
       };
     } catch (error) {
-      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders ?? {}),
+      );
     }
   }
 
@@ -188,13 +193,13 @@ export class GatewayVideoModel implements Experimental_VideoModelV3 {
 
   private getModelConfigHeaders() {
     return {
-      'ai-video-model-specification-version': '3',
+      'ai-video-model-specification-version': '4',
       'ai-model-id': this.modelId,
     };
   }
 }
 
-function maybeEncodeVideoFile(file: Experimental_VideoModelV3File) {
+function maybeEncodeVideoFile(file: Experimental_VideoModelV4File) {
   if (file.type === 'file' && file.data instanceof Uint8Array) {
     return {
       ...file,
@@ -234,6 +239,11 @@ const gatewayVideoWarningSchema = z.discriminatedUnion('type', [
     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(),

package/src/index.ts

@@ -1,14 +1,36 @@
 export type { GatewayModelId } from './gateway-language-model-settings';
+export {
+  GATEWAY_AUTH_SUBPROTOCOL_PREFIX,
+  GATEWAY_REALTIME_SUBPROTOCOL,
+  GATEWAY_TEAM_SUBPROTOCOL_PREFIX,
+  getGatewayRealtimeAuthToken,
+  getGatewayRealtimeProtocols,
+  getGatewayRealtimeTeamIdOrSlug,
+} from './gateway-realtime-auth';
+export type { GatewayRealtimeModelId } from './gateway-realtime-model-settings';
+export type { GatewayRerankingModelId } from './gateway-reranking-model-settings';
+export type { GatewaySpeechModelId } from './gateway-speech-model-settings';
+export type { GatewayTranscriptionModelId } from './gateway-transcription-model-settings';
 export type { GatewayVideoModelId } from './gateway-video-model-settings';
 export type {
   GatewayLanguageModelEntry,
   GatewayLanguageModelSpecification,
 } from './gateway-model-entry';
 export type { GatewayCreditsResponse } from './gateway-fetch-metadata';
+export type {
+  GatewaySpendReportParams,
+  GatewaySpendReportRow,
+  GatewaySpendReportResponse,
+} from './gateway-spend-report';
+export type {
+  GatewayGenerationInfoParams,
+  GatewayGenerationInfo,
+} from './gateway-generation-info';
 export type { GatewayLanguageModelEntry as GatewayModelEntry } from './gateway-model-entry';
 export {
-  createGatewayProvider,
-  createGatewayProvider as createGateway,
+  createGateway,
+  /** @deprecated Use `createGateway` instead. */
+  createGateway as createGatewayProvider,
   gateway,
 } from './gateway-provider';
 export type {
@@ -16,13 +38,15 @@ export type {
   GatewayProviderSettings,
 } from './gateway-provider';
 export type {
-  GatewayLanguageModelOptions,
-  /** @deprecated Use `GatewayLanguageModelOptions` instead. */
-  GatewayLanguageModelOptions as GatewayProviderOptions,
+  GatewayProviderOptions,
+  /** @deprecated Use `GatewayProviderOptions` instead. */
+  GatewayProviderOptions as GatewayLanguageModelOptions,
 } from './gateway-provider-options';
 export {
   GatewayError,
   GatewayAuthenticationError,
+  GatewayFailedDependencyError,
+  GatewayForbiddenError,
   GatewayInvalidRequestError,
   GatewayRateLimitError,
   GatewayModelNotFoundError,
@@ -30,3 +54,4 @@ export {
   GatewayResponseError,
 } from './errors';
 export type { GatewayErrorResponse } from './errors';
+export { VERSION } from './version';

package/src/tool/parallel-search.ts

@@ -1,5 +1,5 @@
 import {
-  createProviderToolFactoryWithOutputSchema,
+  createProviderExecutedToolFactory,
   lazySchema,
   zodSchema,
 } from '@ai-sdk/provider-utils';
@@ -278,16 +278,15 @@ const parallelSearchOutputSchema = lazySchema(() =>
   ),
 );
 
-export const parallelSearchToolFactory =
-  createProviderToolFactoryWithOutputSchema<
-    ParallelSearchInput,
-    ParallelSearchOutput,
-    ParallelSearchConfig
-  >({
-    id: 'gateway.parallel_search',
-    inputSchema: parallelSearchInputSchema,
-    outputSchema: parallelSearchOutputSchema,
-  });
+export const parallelSearchToolFactory = createProviderExecutedToolFactory<
+  ParallelSearchInput,
+  ParallelSearchOutput,
+  ParallelSearchConfig
+>({
+  id: 'gateway.parallel_search',
+  inputSchema: parallelSearchInputSchema,
+  outputSchema: parallelSearchOutputSchema,
+});
 
 export const parallelSearch = (
   config: ParallelSearchConfig = {},

package/src/tool/perplexity-search.ts

@@ -1,5 +1,5 @@
 import {
-  createProviderToolFactoryWithOutputSchema,
+  createProviderExecutedToolFactory,
   lazySchema,
   zodSchema,
 } from '@ai-sdk/provider-utils';
@@ -277,16 +277,15 @@ const perplexitySearchOutputSchema = lazySchema(() =>
   ),
 );
 
-export const perplexitySearchToolFactory =
-  createProviderToolFactoryWithOutputSchema<
-    PerplexitySearchInput,
-    PerplexitySearchOutput,
-    PerplexitySearchConfig
-  >({
-    id: 'gateway.perplexity_search',
-    inputSchema: perplexitySearchInputSchema,
-    outputSchema: perplexitySearchOutputSchema,
-  });
+export const perplexitySearchToolFactory = createProviderExecutedToolFactory<
+  PerplexitySearchInput,
+  PerplexitySearchOutput,
+  PerplexitySearchConfig
+>({
+  id: 'gateway.perplexity_search',
+  inputSchema: perplexitySearchInputSchema,
+  outputSchema: perplexitySearchOutputSchema,
+});
 
 export const perplexitySearch = (
   config: PerplexitySearchConfig = {},