@ai-sdk/gateway 0.0.0-64aae7dd-20260114144918 → 0.0.0-98261322-20260122142521

package/src/gateway-language-model.ts

@@ -0,0 +1,212 @@
+import type {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  SharedV3Warning,
+  LanguageModelV3FilePart,
+  LanguageModelV3StreamPart,
+  LanguageModelV3GenerateResult,
+  LanguageModelV3StreamResult,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  postJsonToApi,
+  resolve,
+  type ParseResult,
+  type Resolvable,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import type { GatewayConfig } from './gateway-config';
+import type { GatewayModelId } from './gateway-language-model-settings';
+import { asGatewayError } from './errors';
+import { parseAuthMethod } from './errors/parse-auth-method';
+
+type GatewayChatConfig = GatewayConfig & {
+  provider: string;
+  o11yHeaders: Resolvable<Record<string, string>>;
+};
+
+export class GatewayLanguageModel implements LanguageModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly supportedUrls = { '*/*': [/.*/] };
+
+  constructor(
+    readonly modelId: GatewayModelId,
+    private readonly config: GatewayChatConfig,
+  ) {}
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  private async getArgs(options: LanguageModelV3CallOptions) {
+    const { abortSignal: _abortSignal, ...optionsWithoutSignal } = options;
+
+    return {
+      args: this.maybeEncodeFileParts(optionsWithoutSignal),
+      warnings: [],
+    };
+  }
+
+  async doGenerate(
+    options: LanguageModelV3CallOptions,
+  ): Promise<LanguageModelV3GenerateResult> {
+    const { args, warnings } = await this.getArgs(options);
+    const { abortSignal } = options;
+
+    const resolvedHeaders = await resolve(this.config.headers());
+
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue: rawResponse,
+      } = await postJsonToApi({
+        url: this.getUrl(),
+        headers: combineHeaders(
+          resolvedHeaders,
+          options.headers,
+          this.getModelConfigHeaders(this.modelId, false),
+          await resolve(this.config.o11yHeaders),
+        ),
+        body: args,
+        successfulResponseHandler: createJsonResponseHandler(z.any()),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        ...(abortSignal && { abortSignal }),
+        fetch: this.config.fetch,
+      });
+
+      return {
+        ...responseBody,
+        request: { body: args },
+        response: { headers: responseHeaders, body: rawResponse },
+        warnings,
+      };
+    } catch (error) {
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+
+  async doStream(
+    options: LanguageModelV3CallOptions,
+  ): Promise<LanguageModelV3StreamResult> {
+    const { args, warnings } = await this.getArgs(options);
+    const { abortSignal } = options;
+
+    const resolvedHeaders = await resolve(this.config.headers());
+
+    try {
+      const { value: response, responseHeaders } = await postJsonToApi({
+        url: this.getUrl(),
+        headers: combineHeaders(
+          resolvedHeaders,
+          options.headers,
+          this.getModelConfigHeaders(this.modelId, true),
+          await resolve(this.config.o11yHeaders),
+        ),
+        body: args,
+        successfulResponseHandler: createEventSourceResponseHandler(z.any()),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        ...(abortSignal && { abortSignal }),
+        fetch: this.config.fetch,
+      });
+
+      return {
+        stream: response.pipeThrough(
+          new TransformStream<
+            ParseResult<LanguageModelV3StreamPart>,
+            LanguageModelV3StreamPart
+          >({
+            start(controller) {
+              if (warnings.length > 0) {
+                controller.enqueue({ type: 'stream-start', warnings });
+              }
+            },
+            transform(chunk, controller) {
+              if (chunk.success) {
+                const streamPart = chunk.value;
+
+                // Handle raw chunks: if this is a raw chunk from the gateway API,
+                // only emit it if includeRawChunks is true
+                if (streamPart.type === 'raw' && !options.includeRawChunks) {
+                  return; // Skip raw chunks if not requested
+                }
+
+                if (
+                  streamPart.type === 'response-metadata' &&
+                  streamPart.timestamp &&
+                  typeof streamPart.timestamp === 'string'
+                ) {
+                  streamPart.timestamp = new Date(streamPart.timestamp);
+                }
+
+                controller.enqueue(streamPart);
+              } else {
+                controller.error(
+                  (chunk as { success: false; error: unknown }).error,
+                );
+              }
+            },
+          }),
+        ),
+        request: { body: args },
+        response: { headers: responseHeaders },
+      };
+    } catch (error) {
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+
+  private isFilePart(part: unknown) {
+    return (
+      part && typeof part === 'object' && 'type' in part && part.type === 'file'
+    );
+  }
+
+  /**
+   * Encodes file parts in the prompt to base64. Mutates the passed options
+   * instance directly to avoid copying the file data.
+   * @param options - The options to encode.
+   * @returns The options with the file parts encoded.
+   */
+  private maybeEncodeFileParts(options: LanguageModelV3CallOptions) {
+    for (const message of options.prompt) {
+      for (const part of message.content) {
+        if (this.isFilePart(part)) {
+          const filePart = part as LanguageModelV3FilePart;
+          // If the file part is a URL it will get cleanly converted to a string.
+          // If it's a binary file attachment we convert it to a data url.
+          // In either case, server-side we should only ever see URLs as strings.
+          if (filePart.data instanceof Uint8Array) {
+            const buffer = Uint8Array.from(filePart.data);
+            const base64Data = Buffer.from(buffer).toString('base64');
+            filePart.data = new URL(
+              `data:${filePart.mediaType || 'application/octet-stream'};base64,${base64Data}`,
+            );
+          }
+        }
+      }
+    }
+    return options;
+  }
+
+  private getUrl() {
+    return `${this.config.baseURL}/language-model`;
+  }
+
+  private getModelConfigHeaders(modelId: string, streaming: boolean) {
+    return {
+      'ai-language-model-specification-version': '3',
+      'ai-language-model-id': modelId,
+      'ai-language-model-streaming': String(streaming),
+    };
+  }
+}

package/src/gateway-model-entry.ts

@@ -0,0 +1,58 @@
+import type { LanguageModelV3 } from '@ai-sdk/provider';
+
+export interface GatewayLanguageModelEntry {
+  /**
+   * The model id used by the remote provider in model settings and for specifying the
+   * intended model for text generation.
+   */
+  id: string;
+
+  /**
+   * The display name of the model for presentation in user-facing contexts.
+   */
+  name: string;
+
+  /**
+   * Optional description of the model.
+   */
+  description?: string | null;
+
+  /**
+   * Optional pricing information for the model.
+   */
+  pricing?: {
+    /**
+     * Cost per input token in USD.
+     */
+    input: string;
+    /**
+     * Cost per output token in USD.
+     */
+    output: string;
+    /**
+     * Cost per cached input token in USD.
+     * Only present for providers/models that support prompt caching.
+     */
+    cachedInputTokens?: string;
+    /**
+     * Cost per input token to create/write cache entries in USD.
+     * Only present for providers/models that support prompt caching.
+     */
+    cacheCreationInputTokens?: string;
+  } | null;
+
+  /**
+   * Additional AI SDK language model specifications for the model.
+   */
+  specification: GatewayLanguageModelSpecification;
+
+  /**
+   * Optional field to differentiate between model types.
+   */
+  modelType?: 'language' | 'embedding' | 'image' | null;
+}
+
+export type GatewayLanguageModelSpecification = Pick<
+  LanguageModelV3,
+  'specificationVersion' | 'provider' | 'modelId'
+>;

package/src/gateway-provider-options.ts

@@ -0,0 +1,66 @@
+import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+// https://vercel.com/docs/ai-gateway/provider-options
+const gatewayProviderOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * Array of provider slugs that are the only ones allowed to be used.
+       *
+       * Example: `['azure', 'openai']` will only allow Azure and OpenAI to be used.
+       */
+      only: z.array(z.string()).optional(),
+      /**
+       * Array of provider slugs that specifies the sequence in which providers should be attempted.
+       *
+       * Example: `['bedrock', 'anthropic']` will try Amazon Bedrock first, then Anthropic as fallback.
+       */
+      order: z.array(z.string()).optional(),
+      /**
+       * The unique identifier for the end user on behalf of whom the request was made.
+       *
+       * Used for spend tracking and attribution purposes.
+       */
+      user: z.string().optional(),
+      /**
+       * User-specified tags for use in reporting and filtering usage.
+       *
+       * For example, spend tracking reporting by feature or prompt version.
+       *
+       * Example: `['chat', 'v2']`
+       */
+      tags: z.array(z.string()).optional(),
+      /**
+       * Array of model slugs specifying fallback models to use in order.
+       *
+       * Example: `['openai/gpt-5-nano', 'zai/glm-4.6']` will try `openai/gpt-5-nano` first, then `zai/glm-4.6` as fallback.
+       */
+      models: z.array(z.string()).optional(),
+      /**
+       * Request-scoped BYOK credentials to use instead of cached credentials.
+       *
+       * When provided, cached BYOK credentials are ignored entirely.
+       *
+       * Each provider can have multiple credentials (tried in order).
+       *
+       * Examples:
+       * - Simple: `{ 'anthropic': [{ apiKey: 'sk-ant-...' }] }`
+       * - Multiple: `{ 'vertex': [{ projectId: 'proj-1', privateKey: '...' }, { projectId: 'proj-2', privateKey: '...' }] }`
+       * - Multi-provider: `{ 'anthropic': [{ apiKey: '...' }], 'bedrock': [{ accessKeyId: '...', secretAccessKey: '...' }] }`
+       */
+      byok: z
+        .record(z.string(), z.array(z.record(z.string(), z.unknown())))
+        .optional(),
+      /**
+       * Whether to filter by only providers that state they have zero data
+       * retention with Vercel AI Gateway. When enabled, only providers that
+       * have agreements with Vercel AI Gateway for zero data retention will be
+       * used.
+       */
+      zeroDataRetention: z.boolean().optional(),
+    }),
+  ),
+);
+
+export type GatewayProviderOptions = InferSchema<typeof gatewayProviderOptions>;