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

package/src/gateway-reranking-model.ts

@@ -0,0 +1,142 @@
+import type {
+  RerankingModelV4,
+  SharedV4ProviderMetadata,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  lazySchema,
+  postJsonToApi,
+  resolve,
+  zodSchema,
+  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 GatewayRerankingModel implements RerankingModelV4 {
+  readonly specificationVersion = 'v4';
+
+  constructor(
+    readonly modelId: string,
+    private readonly config: GatewayConfig & {
+      provider: string;
+      o11yHeaders: Resolvable<Record<string, string>>;
+    },
+  ) {}
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  async doRerank({
+    documents,
+    query,
+    topN,
+    headers,
+    abortSignal,
+    providerOptions,
+  }: Parameters<RerankingModelV4['doRerank']>[0]): Promise<
+    Awaited<ReturnType<RerankingModelV4['doRerank']>>
+  > {
+    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: {
+          documents,
+          query,
+          ...(topN != null ? { topN } : {}),
+          ...(providerOptions ? { providerOptions } : {}),
+        },
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayRerankingResponseSchema,
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        ...(abortSignal && { abortSignal }),
+        fetch: this.config.fetch,
+      });
+
+      return {
+        ranking: responseBody.ranking,
+        providerMetadata:
+          responseBody.providerMetadata as unknown as SharedV4ProviderMetadata,
+        response: { headers: responseHeaders, body: rawValue },
+        warnings: responseBody.warnings ?? [],
+      };
+    } catch (error) {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders ?? {}),
+      );
+    }
+  }
+
+  private getUrl() {
+    return `${this.config.baseURL}/reranking-model`;
+  }
+
+  private getModelConfigHeaders() {
+    return {
+      'ai-reranking-model-specification-version': '4',
+      'ai-model-id': this.modelId,
+    };
+  }
+}
+
+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(
+    z.object({
+      ranking: z.array(
+        z.object({
+          index: z.number(),
+          relevanceScore: z.number(),
+        }),
+      ),
+      warnings: z.array(gatewayRerankingWarningSchema).optional(),
+      providerMetadata: z
+        .record(z.string(), z.record(z.string(), z.unknown()))
+        .optional(),
+    }),
+  ),
+);

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

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

package/src/gateway-speech-model.ts

@@ -0,0 +1,145 @@
+import type {
+  SharedV4ProviderMetadata,
+  SharedV4Warning,
+  SpeechModelV4,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  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 GatewaySpeechModel implements SpeechModelV4 {
+  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({
+    text,
+    voice,
+    outputFormat,
+    instructions,
+    speed,
+    language,
+    providerOptions,
+    headers,
+    abortSignal,
+  }: Parameters<SpeechModelV4['doGenerate']>[0]): Promise<
+    Awaited<ReturnType<SpeechModelV4['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: {
+          text,
+          ...(voice && { voice }),
+          ...(outputFormat && { outputFormat }),
+          ...(instructions && { instructions }),
+          ...(speed != null && { speed }),
+          ...(language && { language }),
+          ...(providerOptions && { providerOptions }),
+        },
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewaySpeechResponseSchema,
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        ...(abortSignal && { abortSignal }),
+        fetch: this.config.fetch,
+      });
+
+      return {
+        audio: responseBody.audio,
+        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}/speech-model`;
+  }
+
+  private getModelConfigHeaders() {
+    return {
+      'ai-speech-model-specification-version': '4',
+      'ai-model-id': this.modelId,
+    };
+  }
+}
+
+const providerMetadataEntrySchema = z.object({}).catchall(z.unknown());
+
+const gatewaySpeechWarningSchema = 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 gatewaySpeechResponseSchema = z.object({
+  audio: z.string(),
+  warnings: z.array(gatewaySpeechWarningSchema).optional(),
+  providerMetadata: z
+    .record(z.string(), providerMetadataEntrySchema)
+    .optional(),
+});

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 & {});