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

package/src/gateway-provider.ts

@@ -1,50 +1,74 @@
 import {
   loadOptionalSetting,
   withoutTrailingSlash,
+  withUserAgentSuffix,
   type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { asGatewayError, GatewayAuthenticationError } from './errors';
 import {
   GATEWAY_AUTH_METHOD_HEADER,
-  parseAuthMethod,
-} from './errors/parse-auth-method';
+  VERCEL_AI_GATEWAY_TEAM_HEADER,
+} from './gateway-headers';
+import { parseAuthMethod } from './errors/parse-auth-method';
 import {
   GatewayFetchMetadata,
   type GatewayFetchMetadataResponse,
   type GatewayCreditsResponse,
 } from './gateway-fetch-metadata';
+import {
+  GatewaySpendReport,
+  type GatewaySpendReportParams,
+  type GatewaySpendReportResponse,
+} from './gateway-spend-report';
+import {
+  GatewayGenerationInfoFetcher,
+  type GatewayGenerationInfoParams,
+  type GatewayGenerationInfo,
+} from './gateway-generation-info';
 import { GatewayLanguageModel } from './gateway-language-model';
 import { GatewayEmbeddingModel } from './gateway-embedding-model';
 import { GatewayImageModel } from './gateway-image-model';
 import { GatewayVideoModel } from './gateway-video-model';
+import { GatewayRerankingModel } from './gateway-reranking-model';
+import { GatewaySpeechModel } from './gateway-speech-model';
+import { GatewayTranscriptionModel } from './gateway-transcription-model';
+import { GatewayRealtimeModel } from './gateway-realtime-model';
 import type { GatewayEmbeddingModelId } from './gateway-embedding-model-settings';
 import type { GatewayImageModelId } from './gateway-image-model-settings';
+import type { GatewayRerankingModelId } from './gateway-reranking-model-settings';
+import type { GatewaySpeechModelId } from './gateway-speech-model-settings';
+import type { GatewayTranscriptionModelId } from './gateway-transcription-model-settings';
+import type { GatewayRealtimeModelId } from './gateway-realtime-model-settings';
 import type { GatewayVideoModelId } from './gateway-video-model-settings';
 import { gatewayTools } from './gateway-tools';
 import { getVercelOidcToken, getVercelRequestId } from './vercel-environment';
 import type { GatewayModelId } from './gateway-language-model-settings';
 import type {
-  LanguageModelV3,
-  EmbeddingModelV3,
-  ImageModelV3,
-  Experimental_VideoModelV3,
-  ProviderV3,
+  LanguageModelV4,
+  EmbeddingModelV4,
+  ImageModelV4,
+  RerankingModelV4,
+  SpeechModelV4,
+  TranscriptionModelV4,
+  Experimental_VideoModelV4,
+  Experimental_RealtimeFactoryV4 as RealtimeFactoryV4,
+  Experimental_RealtimeFactoryV4GetTokenOptions as RealtimeFactoryV4GetTokenOptions,
+  ProviderV4,
 } from '@ai-sdk/provider';
-import { withUserAgentSuffix } from '@ai-sdk/provider-utils';
 import { VERSION } from './version';
 
-export interface GatewayProvider extends ProviderV3 {
-  (modelId: GatewayModelId): LanguageModelV3;
+export interface GatewayProvider extends ProviderV4 {
+  (modelId: GatewayModelId): LanguageModelV4;
 
   /**
    * Creates a model for text generation.
    */
-  chat(modelId: GatewayModelId): LanguageModelV3;
+  chat(modelId: GatewayModelId): LanguageModelV4;
 
   /**
    * Creates a model for text generation.
    */
-  languageModel(modelId: GatewayModelId): LanguageModelV3;
+  languageModel(modelId: GatewayModelId): LanguageModelV4;
 
   /**
    * Returns available providers and models for use with the remote provider.
@@ -56,40 +80,94 @@ export interface GatewayProvider extends ProviderV3 {
    */
   getCredits(): Promise<GatewayCreditsResponse>;
 
+  /**
+   * Returns a spend report with cost, token, and request count data,
+   * aggregated by the specified dimension.
+   */
+  getSpendReport(
+    params: GatewaySpendReportParams,
+  ): Promise<GatewaySpendReportResponse>;
+
+  /**
+   * Returns detailed information about a specific generation by its ID,
+   * including cost, token usage, latency, and provider details.
+   */
+  getGenerationInfo(
+    params: GatewayGenerationInfoParams,
+  ): Promise<GatewayGenerationInfo>;
+
   /**
    * Creates a model for generating text embeddings.
    */
-  embedding(modelId: GatewayEmbeddingModelId): EmbeddingModelV3;
+  embedding(modelId: GatewayEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * Creates a model for generating text embeddings.
    */
-  embeddingModel(modelId: GatewayEmbeddingModelId): EmbeddingModelV3;
+  embeddingModel(modelId: GatewayEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * @deprecated Use `embeddingModel` instead.
    */
-  textEmbeddingModel(modelId: GatewayEmbeddingModelId): EmbeddingModelV3;
+  textEmbeddingModel(modelId: GatewayEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * Creates a model for generating images.
    */
-  image(modelId: GatewayImageModelId): ImageModelV3;
+  image(modelId: GatewayImageModelId): ImageModelV4;
 
   /**
    * Creates a model for generating images.
    */
-  imageModel(modelId: GatewayImageModelId): ImageModelV3;
+  imageModel(modelId: GatewayImageModelId): ImageModelV4;
 
   /**
    * Creates a model for generating videos.
    */
-  video(modelId: GatewayVideoModelId): Experimental_VideoModelV3;
+  video(modelId: GatewayVideoModelId): Experimental_VideoModelV4;
 
   /**
    * Creates a model for generating videos.
    */
-  videoModel(modelId: GatewayVideoModelId): Experimental_VideoModelV3;
+  videoModel(modelId: GatewayVideoModelId): Experimental_VideoModelV4;
+
+  /**
+   * Creates a model for reranking documents.
+   */
+  reranking(modelId: GatewayRerankingModelId): RerankingModelV4;
+
+  /**
+   * Creates a model for reranking documents.
+   */
+  rerankingModel(modelId: GatewayRerankingModelId): RerankingModelV4;
+
+  /**
+   * Creates a model for text-to-speech generation.
+   */
+  speech(modelId: GatewaySpeechModelId): SpeechModelV4;
+
+  /**
+   * Creates a model for text-to-speech generation.
+   */
+  speechModel(modelId: GatewaySpeechModelId): SpeechModelV4;
+
+  /**
+   * Creates a model for audio transcription.
+   */
+  transcription(modelId: GatewayTranscriptionModelId): TranscriptionModelV4;
+
+  /**
+   * Creates a model for audio transcription.
+   */
+  transcriptionModel(
+    modelId: GatewayTranscriptionModelId,
+  ): TranscriptionModelV4;
+
+  /**
+   * Creates an experimental realtime model for bidirectional audio/text
+   * communication over WebSocket, normalized through the AI Gateway.
+   */
+  experimental_realtime: RealtimeFactoryV4;
 
   /**
    * Gateway-specific tools executed server-side.
@@ -99,15 +177,22 @@ export interface GatewayProvider extends ProviderV3 {
 
 export interface GatewayProviderSettings {
   /**
-   * The base URL prefix for API calls. Defaults to `https://ai-gateway.vercel.sh/v1/ai`.
+   * The base URL prefix for API calls. Defaults to `https://ai-gateway.vercel.sh/v4/ai`.
    */
   baseURL?: string;
 
   /**
-   * API key that is being sent using the `Authorization` header.
+   * API key or Vercel access token that is being sent using the `Authorization`
+   * header. It defaults to the `AI_GATEWAY_API_KEY` environment variable.
    */
   apiKey?: string;
 
+  /**
+   * Vercel team ID or slug to scope requests for access tokens that can access
+   * multiple teams.
+   */
+  teamIdOrSlug?: string;
+
   /**
    * Custom headers to include in the requests.
    */
@@ -137,7 +222,7 @@ const AI_GATEWAY_PROTOCOL_VERSION = '0.0.1';
 /**
  * Create a remote provider instance.
  */
-export function createGatewayProvider(
+export function createGateway(
   options: GatewayProviderSettings = {},
 ): GatewayProvider {
   let pendingMetadata: Promise<GatewayFetchMetadataResponse> | null = null;
@@ -148,20 +233,41 @@ export function createGatewayProvider(
 
   const baseURL =
     withoutTrailingSlash(options.baseURL) ??
-    'https://ai-gateway.vercel.sh/v3/ai';
+    'https://ai-gateway.vercel.sh/v4/ai';
+
+  const createAuthHeaders = (auth: {
+    token: string;
+    authMethod: 'api-key' | 'oidc';
+  }) =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${auth.token}`,
+        'ai-gateway-protocol-version': AI_GATEWAY_PROTOCOL_VERSION,
+        [GATEWAY_AUTH_METHOD_HEADER]: auth.authMethod,
+        ...(options.teamIdOrSlug != null
+          ? { [VERCEL_AI_GATEWAY_TEAM_HEADER]: options.teamIdOrSlug }
+          : {}),
+        ...options.headers,
+      },
+      `ai-sdk/gateway/${VERSION}`,
+    );
 
   const getHeaders = async () => {
     try {
-      const auth = await getGatewayAuthToken(options);
-      return withUserAgentSuffix(
-        {
-          Authorization: `Bearer ${auth.token}`,
-          'ai-gateway-protocol-version': AI_GATEWAY_PROTOCOL_VERSION,
-          [GATEWAY_AUTH_METHOD_HEADER]: auth.authMethod,
-          ...options.headers,
-        },
-        `ai-sdk/gateway/${VERSION}`,
-      );
+      return createAuthHeaders(await getGatewayAuthToken(options));
+    } catch (error) {
+      throw GatewayAuthenticationError.createContextualError({
+        apiKeyProvided: false,
+        oidcTokenProvided: false,
+        statusCode: 401,
+        cause: error,
+      });
+    }
+  };
+
+  const getRealtimeAuthToken = async () => {
+    try {
+      return await getGatewayAuthToken(options);
     } catch (error) {
       throw GatewayAuthenticationError.createContextualError({
         apiKeyProvided: false,
@@ -253,6 +359,36 @@ export function createGatewayProvider(
       });
   };
 
+  const getSpendReport = async (params: GatewaySpendReportParams) => {
+    return new GatewaySpendReport({
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    })
+      .getSpendReport(params)
+      .catch(async (error: unknown) => {
+        throw await asGatewayError(
+          error,
+          await parseAuthMethod(await getHeaders()),
+        );
+      });
+  };
+
+  const getGenerationInfo = async (params: GatewayGenerationInfoParams) => {
+    return new GatewayGenerationInfoFetcher({
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    })
+      .getGenerationInfo(params)
+      .catch(async (error: unknown) => {
+        throw await asGatewayError(
+          error,
+          await parseAuthMethod(await getHeaders()),
+        );
+      });
+  };
+
   const provider = function (modelId: GatewayModelId) {
     if (new.target) {
       throw new Error(
@@ -263,9 +399,11 @@ export function createGatewayProvider(
     return createLanguageModel(modelId);
   };
 
-  provider.specificationVersion = 'v3' as const;
+  provider.specificationVersion = 'v4' as const;
   provider.getAvailableModels = getAvailableModels;
   provider.getCredits = getCredits;
+  provider.getSpendReport = getSpendReport;
+  provider.getGenerationInfo = getGenerationInfo;
   provider.imageModel = (modelId: GatewayImageModelId) => {
     return new GatewayImageModel(modelId, {
       provider: 'gateway',
@@ -296,6 +434,64 @@ export function createGatewayProvider(
       o11yHeaders: createO11yHeaders(),
     });
   };
+  const createRerankingModel = (modelId: GatewayRerankingModelId) => {
+    return new GatewayRerankingModel(modelId, {
+      provider: 'gateway',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders(),
+    });
+  };
+  provider.rerankingModel = createRerankingModel;
+  provider.reranking = createRerankingModel;
+  const createSpeechModel = (modelId: GatewaySpeechModelId) => {
+    return new GatewaySpeechModel(modelId, {
+      provider: 'gateway',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders(),
+    });
+  };
+  provider.speechModel = createSpeechModel;
+  provider.speech = createSpeechModel;
+  const createTranscriptionModel = (modelId: GatewayTranscriptionModelId) => {
+    return new GatewayTranscriptionModel(modelId, {
+      provider: 'gateway',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders(),
+    });
+  };
+  provider.transcriptionModel = createTranscriptionModel;
+  provider.transcription = createTranscriptionModel;
+
+  const createRealtimeModel = (modelId: GatewayRealtimeModelId) => {
+    assertGatewayRealtimeServerEnvironment();
+    return new GatewayRealtimeModel(modelId, {
+      provider: 'gateway.realtime',
+      baseURL,
+      teamIdOrSlug: options.teamIdOrSlug,
+      getAuthToken: getRealtimeAuthToken,
+    });
+  };
+  provider.experimental_realtime = Object.assign(
+    (modelId: GatewayRealtimeModelId) => createRealtimeModel(modelId),
+    {
+      getToken: async (tokenOptions: RealtimeFactoryV4GetTokenOptions) => {
+        const model = createRealtimeModel(tokenOptions.model);
+        const secret = await model.doCreateClientSecret();
+        return {
+          token: secret.token,
+          url: secret.url,
+          ...(secret.expiresAt != null && { expiresAt: secret.expiresAt }),
+        };
+      },
+    },
+  ) as RealtimeFactoryV4;
+
   provider.chat = provider.languageModel;
   provider.embedding = provider.embeddingModel;
   provider.image = provider.imageModel;
@@ -304,7 +500,7 @@ export function createGatewayProvider(
   return provider;
 }
 
-export const gateway = createGatewayProvider();
+export const gateway = createGateway();
 
 export async function getGatewayAuthToken(
   options: GatewayProviderSettings,
@@ -327,3 +523,11 @@ export async function getGatewayAuthToken(
     authMethod: 'oidc',
   };
 }
+
+function assertGatewayRealtimeServerEnvironment(): void {
+  if (typeof globalThis.window !== 'undefined') {
+    throw new Error(
+      'AI Gateway realtime models cannot be used in browsers yet. Use gateway.experimental_realtime from server-side code only.',
+    );
+  }
+}

package/src/gateway-realtime-auth.ts

@@ -0,0 +1,126 @@
+/**
+ * Shared WebSocket subprotocol contract for AI Gateway realtime auth.
+ *
+ * The browser `WebSocket` API cannot set request headers, so the Gateway auth
+ * (bearer) token is carried through the `Sec-WebSocket-Protocol` handshake
+ * instead of an `Authorization` header — the same workaround OpenAI uses for
+ * `openai-insecure-api-key.<token>`.
+ *
+ * This module is the single source of truth for that contract so the client and
+ * the Gateway server can't drift: the client encodes values with
+ * `getGatewayRealtimeProtocols`, and the Gateway server decodes them with
+ * `getGatewayRealtimeAuthToken` / `getGatewayRealtimeTeamIdOrSlug`.
+ *
+ * WebSocket subprotocol values must fit the RFC token grammar. The auth token is
+ * sent as-is, so callers must use tokens that are valid subprotocol tokens; the
+ * optional team scope is base64url-encoded by this module. Keep the complete
+ * `Sec-WebSocket-Protocol` header compact (target under an 8 KiB safe header
+ * budget) because intermediaries may reject large upgrade headers.
+ */
+
+/**
+ * Marker subprotocol offered on every handshake so the Gateway can echo a
+ * negotiated subprotocol on the 101 response (some clients require the server to
+ * select one of the offered subprotocols).
+ */
+export const GATEWAY_REALTIME_SUBPROTOCOL = 'ai-gateway-realtime.v1';
+
+/** Subprotocol prefix that carries the Gateway auth (bearer) token. */
+export const GATEWAY_AUTH_SUBPROTOCOL_PREFIX = 'ai-gateway-auth.';
+
+/** Subprotocol prefix that carries optional Vercel team scoping. */
+export const GATEWAY_TEAM_SUBPROTOCOL_PREFIX = 'ai-gateway-team.';
+
+/**
+ * Client-side: build the WebSocket subprotocols that carry `token` to the
+ * Gateway. Pass the result as the second argument to `new WebSocket(url, ...)`.
+ */
+export function getGatewayRealtimeProtocols(
+  token: string,
+  options?: { teamIdOrSlug?: string },
+): string[] {
+  const protocols = [
+    GATEWAY_REALTIME_SUBPROTOCOL,
+    `${GATEWAY_AUTH_SUBPROTOCOL_PREFIX}${token}`,
+  ];
+
+  if (options?.teamIdOrSlug) {
+    protocols.push(
+      `${GATEWAY_TEAM_SUBPROTOCOL_PREFIX}${encodeSubprotocolValue(options.teamIdOrSlug)}`,
+    );
+  }
+
+  return protocols;
+}
+
+/**
+ * Server-side: extract the Gateway auth (bearer) token from a
+ * `Sec-WebSocket-Protocol` header value, or `undefined` when it is absent or
+ * empty. The Gateway upgrade handler turns this into an
+ * `Authorization: Bearer <token>` before its normal auth path.
+ *
+ * Accepts the raw header value (subprotocols are comma-separated and may carry
+ * surrounding whitespace).
+ */
+export function getGatewayRealtimeAuthToken(
+  secWebSocketProtocol: string | null | undefined,
+): string | undefined {
+  // `findProtocol` trims the protocol, so the sliced token needs no further
+  // trimming; `|| undefined` collapses the empty-token case.
+  return (
+    findProtocol(secWebSocketProtocol, GATEWAY_AUTH_SUBPROTOCOL_PREFIX)?.slice(
+      GATEWAY_AUTH_SUBPROTOCOL_PREFIX.length,
+    ) || undefined
+  );
+}
+
+/**
+ * Server-side: extract the optional Vercel team ID or slug from the
+ * `Sec-WebSocket-Protocol` header value. Team scoping is base64url-encoded so
+ * arbitrary team slugs stay within the WebSocket subprotocol token grammar.
+ */
+export function getGatewayRealtimeTeamIdOrSlug(
+  secWebSocketProtocol: string | null | undefined,
+): string | undefined {
+  const encoded = findProtocol(
+    secWebSocketProtocol,
+    GATEWAY_TEAM_SUBPROTOCOL_PREFIX,
+  )?.slice(GATEWAY_TEAM_SUBPROTOCOL_PREFIX.length);
+  if (!encoded) return undefined;
+
+  try {
+    return decodeSubprotocolValue(encoded) || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function findProtocol(
+  secWebSocketProtocol: string | null | undefined,
+  prefix: string,
+): string | undefined {
+  return secWebSocketProtocol
+    ?.split(',')
+    .map(protocol => protocol.trim())
+    .find(protocol => protocol.startsWith(prefix));
+}
+
+function encodeSubprotocolValue(value: string): string {
+  const bytes = new TextEncoder().encode(value);
+  let binary = '';
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary)
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/u, '');
+}
+
+function decodeSubprotocolValue(value: string): string {
+  const base64 = value.replace(/-/g, '+').replace(/_/g, '/');
+  const padding = '='.repeat((4 - (base64.length % 4)) % 4);
+  const binary = atob(`${base64}${padding}`);
+  const bytes = Uint8Array.from(binary, char => char.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}

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

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

package/src/gateway-realtime-model.ts

@@ -0,0 +1,107 @@
+import type {
+  Experimental_RealtimeModelV4 as RealtimeModelV4,
+  Experimental_RealtimeModelV4ClientEvent as RealtimeModelV4ClientEvent,
+  Experimental_RealtimeModelV4ClientSecretResult as RealtimeModelV4ClientSecretResult,
+  Experimental_RealtimeModelV4ServerEvent as RealtimeModelV4ServerEvent,
+  Experimental_RealtimeModelV4SessionConfig as RealtimeModelV4SessionConfig,
+} from '@ai-sdk/provider';
+import { getGatewayRealtimeProtocols } from './gateway-realtime-auth';
+
+export type GatewayRealtimeModelConfig = {
+  provider: string;
+  baseURL: string;
+  teamIdOrSlug?: string;
+  /**
+   * Resolves the Gateway auth token used to authenticate the WebSocket upgrade
+   * (API key or Vercel OIDC token).
+   */
+  getAuthToken: () => PromiseLike<{
+    token: string;
+    authMethod: 'api-key' | 'oidc';
+  }>;
+};
+
+/**
+ * Realtime model backed by the AI Gateway.
+ *
+ * The Gateway normalizes realtime exactly like it normalizes every other
+ * modality: the client speaks the normalized AI SDK realtime protocol and the
+ * Gateway translates to and from the upstream provider server-side. This model
+ * is therefore a thin identity codec over that normalized protocol — only the
+ * connection and authentication are Gateway-specific.
+ */
+export class GatewayRealtimeModel implements RealtimeModelV4 {
+  readonly specificationVersion = 'v4' as const;
+  readonly provider: string;
+  readonly modelId: string;
+
+  private readonly config: GatewayRealtimeModelConfig;
+
+  constructor(modelId: string, config: GatewayRealtimeModelConfig) {
+    this.modelId = modelId;
+    this.provider = config.provider;
+    this.config = config;
+  }
+
+  /**
+   * Unlike providers with a dedicated ephemeral-secret endpoint (e.g. OpenAI),
+   * the Gateway v0 realtime path does not mint a new client secret. The returned
+   * token is the Gateway credential resolved by the provider (`apiKey`,
+   * `AI_GATEWAY_API_KEY`, or Vercel OIDC token) and the WebSocket upgrade is
+   * authenticated directly with that credential. The
+   * `RealtimeModelV4ClientSecretOptions` are therefore intentionally unused:
+   * `sessionConfig` is applied later via the normalized `session-update` event,
+   * and `expiresAfterSeconds` has no Gateway-side equivalent.
+   */
+  async doCreateClientSecret(): Promise<RealtimeModelV4ClientSecretResult> {
+    const { token } = await this.config.getAuthToken();
+    return {
+      token,
+      url: toGatewayRealtimeUrl(this.config.baseURL, this.modelId),
+    };
+  }
+
+  getWebSocketConfig(options: { token: string; url: string }): {
+    url: string;
+    protocols?: string[];
+  } {
+    return {
+      url: options.url,
+      protocols: getGatewayRealtimeProtocols(options.token, {
+        teamIdOrSlug: this.config.teamIdOrSlug,
+      }),
+    };
+  }
+
+  parseServerEvent(raw: unknown): RealtimeModelV4ServerEvent {
+    // The Gateway emits normalized AI SDK realtime events, so no
+    // provider-specific mapping is needed on the client.
+    return raw as RealtimeModelV4ServerEvent;
+  }
+
+  serializeClientEvent(event: RealtimeModelV4ClientEvent): unknown {
+    // The Gateway accepts normalized AI SDK realtime events directly.
+    return event;
+  }
+
+  buildSessionConfig(config: RealtimeModelV4SessionConfig): unknown {
+    // The session config is already normalized; the Gateway maps it to the
+    // upstream provider's session payload server-side.
+    return config;
+  }
+}
+
+/**
+ * Build the Gateway realtime WebSocket URL. The HTTP(S) base URL is upgraded to
+ * WS(S) and the model id rides the `?ai-model-id=` query — the WS transport of
+ * the `ai-model-id` header the HTTP routes use, since a browser `WebSocket`
+ * cannot set headers. The model id is passed through verbatim; the Gateway owns
+ * resolution (including the bare → `openai/` qualification), exactly like the
+ * non-realtime routes. The query is slash-safe for qualified ids such as
+ * `openai/gpt-realtime-2`.
+ */
+function toGatewayRealtimeUrl(baseURL: string, modelId: string): string {
+  const url = new URL(`${baseURL.replace(/^http/, 'ws')}/realtime-model`);
+  url.searchParams.set('ai-model-id', modelId);
+  return url.toString();
+}

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

@@ -0,0 +1,7 @@
+export type GatewayRerankingModelId =
+  | 'cohere/rerank-v3.5'
+  | 'cohere/rerank-v4-fast'
+  | 'cohere/rerank-v4-pro'
+  | 'voyage/rerank-2.5'
+  | 'voyage/rerank-2.5-lite'
+  | (string & {});