@ai-sdk/gateway 0.0.0-02dba89b-20251009204516 → 0.0.0-4115c213-20260122152721

package/src/gateway-fetch-metadata.ts

@@ -0,0 +1,127 @@
+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';
+import type { GatewayLanguageModelEntry } from './gateway-model-entry';
+
+type GatewayFetchMetadataConfig = GatewayConfig;
+
+export interface GatewayFetchMetadataResponse {
+  models: GatewayLanguageModelEntry[];
+}
+
+export interface GatewayCreditsResponse {
+  /** The remaining gateway credit balance available for API usage */
+  balance: string;
+  /** The total amount of gateway credits that have been consumed */
+  totalUsed: string;
+}
+
+export class GatewayFetchMetadata {
+  constructor(private readonly config: GatewayFetchMetadataConfig) {}
+
+  async getAvailableModels(): Promise<GatewayFetchMetadataResponse> {
+    try {
+      const { value } = await getFromApi({
+        url: `${this.config.baseURL}/config`,
+        headers: await resolve(this.config.headers()),
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayAvailableModelsResponseSchema,
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        fetch: this.config.fetch,
+      });
+
+      return value;
+    } catch (error) {
+      throw await asGatewayError(error);
+    }
+  }
+
+  async getCredits(): Promise<GatewayCreditsResponse> {
+    try {
+      const baseUrl = new URL(this.config.baseURL);
+
+      const { value } = await getFromApi({
+        url: `${baseUrl.origin}/v1/credits`,
+        headers: await resolve(this.config.headers()),
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayCreditsResponseSchema,
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        fetch: this.config.fetch,
+      });
+
+      return value;
+    } catch (error) {
+      throw await asGatewayError(error);
+    }
+  }
+}
+
+const gatewayAvailableModelsResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      models: z.array(
+        z.object({
+          id: z.string(),
+          name: z.string(),
+          description: z.string().nullish(),
+          pricing: z
+            .object({
+              input: z.string(),
+              output: z.string(),
+              input_cache_read: z.string().nullish(),
+              input_cache_write: z.string().nullish(),
+            })
+            .transform(
+              ({ input, output, input_cache_read, input_cache_write }) => ({
+                input,
+                output,
+                ...(input_cache_read
+                  ? { cachedInputTokens: input_cache_read }
+                  : {}),
+                ...(input_cache_write
+                  ? { cacheCreationInputTokens: input_cache_write }
+                  : {}),
+              }),
+            )
+            .nullish(),
+          specification: z.object({
+            specificationVersion: z.literal('v3'),
+            provider: z.string(),
+            modelId: z.string(),
+          }),
+          modelType: z.enum(['language', 'embedding', 'image']).nullish(),
+        }),
+      ),
+    }),
+  ),
+);
+
+const gatewayCreditsResponseSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        balance: z.string(),
+        total_used: z.string(),
+      })
+      .transform(({ balance, total_used }) => ({
+        balance,
+        totalUsed: total_used,
+      })),
+  ),
+);

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

@@ -0,0 +1,12 @@
+export type GatewayImageModelId =
+  | 'bfl/flux-kontext-max'
+  | 'bfl/flux-kontext-pro'
+  | 'bfl/flux-pro-1.0-fill'
+  | 'bfl/flux-pro-1.1'
+  | 'bfl/flux-pro-1.1-ultra'
+  | 'google/imagen-4.0-fast-generate-001'
+  | 'google/imagen-4.0-generate-001'
+  | 'google/imagen-4.0-ultra-generate-001'
+  | 'recraft/recraft-v2'
+  | 'recraft/recraft-v3'
+  | (string & {});

package/src/gateway-image-model.ts

@@ -0,0 +1,145 @@
+import type {
+  ImageModelV3,
+  ImageModelV3File,
+  ImageModelV3ProviderMetadata,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler,
+  createJsonErrorResponseHandler,
+  postJsonToApi,
+  resolve,
+  type Resolvable,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import type { GatewayConfig } from './gateway-config';
+import { asGatewayError } from './errors';
+import { parseAuthMethod } from './errors/parse-auth-method';
+
+export class GatewayImageModel implements ImageModelV3 {
+  readonly specificationVersion = 'v3' as const;
+  // Set a very large number to prevent client-side splitting of requests
+  readonly maxImagesPerCall = Number.MAX_SAFE_INTEGER;
+
+  constructor(
+    readonly modelId: string,
+    private readonly config: GatewayConfig & {
+      provider: string;
+      o11yHeaders: Resolvable<Record<string, string>>;
+    },
+  ) {}
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    files,
+    mask,
+    providerOptions,
+    headers,
+    abortSignal,
+  }: Parameters<ImageModelV3['doGenerate']>[0]): Promise<
+    Awaited<ReturnType<ImageModelV3['doGenerate']>>
+  > {
+    const resolvedHeaders = await resolve(this.config.headers());
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue,
+      } = await postJsonToApi({
+        url: this.getUrl(),
+        headers: combineHeaders(
+          resolvedHeaders,
+          headers ?? {},
+          this.getModelConfigHeaders(),
+          await resolve(this.config.o11yHeaders),
+        ),
+        body: {
+          prompt,
+          n,
+          ...(size && { size }),
+          ...(aspectRatio && { aspectRatio }),
+          ...(seed && { seed }),
+          ...(providerOptions && { providerOptions }),
+          ...(files && {
+            files: files.map(file => maybeEncodeImageFile(file)),
+          }),
+          ...(mask && { mask: maybeEncodeImageFile(mask) }),
+        },
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayImageResponseSchema,
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        ...(abortSignal && { abortSignal }),
+        fetch: this.config.fetch,
+      });
+
+      return {
+        images: responseBody.images, // Always base64 strings from server
+        warnings: responseBody.warnings ?? [],
+        providerMetadata:
+          responseBody.providerMetadata as ImageModelV3ProviderMetadata,
+        response: {
+          timestamp: new Date(),
+          modelId: this.modelId,
+          headers: responseHeaders,
+        },
+      };
+    } catch (error) {
+      throw asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+
+  private getUrl() {
+    return `${this.config.baseURL}/image-model`;
+  }
+
+  private getModelConfigHeaders() {
+    return {
+      'ai-image-model-specification-version': '3',
+      'ai-model-id': this.modelId,
+    };
+  }
+}
+
+function maybeEncodeImageFile(file: ImageModelV3File) {
+  if (file.type === 'file' && file.data instanceof Uint8Array) {
+    return {
+      ...file,
+      data: convertUint8ArrayToBase64(file.data),
+    };
+  }
+  return file;
+}
+
+const providerMetadataEntrySchema = z
+  .object({
+    images: z.array(z.unknown()).optional(),
+  })
+  .catchall(z.unknown());
+
+const gatewayImageResponseSchema = z.object({
+  images: z.array(z.string()), // Always base64 strings over the wire
+  warnings: z
+    .array(
+      z.object({
+        type: z.literal('other'),
+        message: z.string(),
+      }),
+    )
+    .optional(),
+  providerMetadata: z
+    .record(z.string(), providerMetadataEntrySchema)
+    .optional(),
+});

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

@@ -0,0 +1,159 @@
+export type GatewayModelId =
+  | 'alibaba/qwen-3-14b'
+  | 'alibaba/qwen-3-235b'
+  | 'alibaba/qwen-3-30b'
+  | 'alibaba/qwen-3-32b'
+  | 'alibaba/qwen3-235b-a22b-thinking'
+  | 'alibaba/qwen3-coder'
+  | 'alibaba/qwen3-coder-30b-a3b'
+  | 'alibaba/qwen3-coder-plus'
+  | 'alibaba/qwen3-max'
+  | 'alibaba/qwen3-max-preview'
+  | 'alibaba/qwen3-next-80b-a3b-instruct'
+  | 'alibaba/qwen3-next-80b-a3b-thinking'
+  | 'alibaba/qwen3-vl-instruct'
+  | 'alibaba/qwen3-vl-thinking'
+  | 'amazon/nova-2-lite'
+  | 'amazon/nova-lite'
+  | 'amazon/nova-micro'
+  | 'amazon/nova-pro'
+  | 'anthropic/claude-3-haiku'
+  | 'anthropic/claude-3-opus'
+  | 'anthropic/claude-3.5-haiku'
+  | 'anthropic/claude-3.5-sonnet'
+  | 'anthropic/claude-3.5-sonnet-20240620'
+  | 'anthropic/claude-3.7-sonnet'
+  | 'anthropic/claude-haiku-4.5'
+  | 'anthropic/claude-opus-4'
+  | 'anthropic/claude-opus-4.1'
+  | 'anthropic/claude-opus-4.5'
+  | 'anthropic/claude-sonnet-4'
+  | 'anthropic/claude-sonnet-4.5'
+  | 'arcee-ai/trinity-mini'
+  | 'bytedance/seed-1.6'
+  | 'bytedance/seed-1.8'
+  | 'cohere/command-a'
+  | 'deepseek/deepseek-r1'
+  | 'deepseek/deepseek-v3'
+  | 'deepseek/deepseek-v3.1'
+  | 'deepseek/deepseek-v3.1-terminus'
+  | 'deepseek/deepseek-v3.2'
+  | 'deepseek/deepseek-v3.2-exp'
+  | 'deepseek/deepseek-v3.2-thinking'
+  | 'google/gemini-2.0-flash'
+  | 'google/gemini-2.0-flash-lite'
+  | 'google/gemini-2.5-flash'
+  | 'google/gemini-2.5-flash-image'
+  | 'google/gemini-2.5-flash-image-preview'
+  | 'google/gemini-2.5-flash-lite'
+  | 'google/gemini-2.5-flash-lite-preview-09-2025'
+  | 'google/gemini-2.5-flash-preview-09-2025'
+  | 'google/gemini-2.5-pro'
+  | 'google/gemini-3-flash'
+  | 'google/gemini-3-pro-image'
+  | 'google/gemini-3-pro-preview'
+  | 'inception/mercury-coder-small'
+  | 'kwaipilot/kat-coder-pro-v1'
+  | 'meituan/longcat-flash-chat'
+  | 'meituan/longcat-flash-thinking'
+  | 'meta/llama-3.1-70b'
+  | 'meta/llama-3.1-8b'
+  | 'meta/llama-3.2-11b'
+  | 'meta/llama-3.2-1b'
+  | 'meta/llama-3.2-3b'
+  | 'meta/llama-3.2-90b'
+  | 'meta/llama-3.3-70b'
+  | 'meta/llama-4-maverick'
+  | 'meta/llama-4-scout'
+  | 'minimax/minimax-m2'
+  | 'minimax/minimax-m2.1'
+  | 'minimax/minimax-m2.1-lightning'
+  | 'mistral/codestral'
+  | 'mistral/devstral-2'
+  | 'mistral/devstral-small'
+  | 'mistral/devstral-small-2'
+  | 'mistral/magistral-medium'
+  | 'mistral/magistral-small'
+  | 'mistral/ministral-14b'
+  | 'mistral/ministral-3b'
+  | 'mistral/ministral-8b'
+  | 'mistral/mistral-large-3'
+  | 'mistral/mistral-medium'
+  | 'mistral/mistral-nemo'
+  | 'mistral/mistral-small'
+  | 'mistral/mixtral-8x22b-instruct'
+  | 'mistral/pixtral-12b'
+  | 'mistral/pixtral-large'
+  | 'moonshotai/kimi-k2'
+  | 'moonshotai/kimi-k2-0905'
+  | 'moonshotai/kimi-k2-thinking'
+  | 'moonshotai/kimi-k2-thinking-turbo'
+  | 'moonshotai/kimi-k2-turbo'
+  | 'morph/morph-v3-fast'
+  | 'morph/morph-v3-large'
+  | 'nvidia/nemotron-3-nano-30b-a3b'
+  | 'nvidia/nemotron-nano-12b-v2-vl'
+  | 'nvidia/nemotron-nano-9b-v2'
+  | 'openai/codex-mini'
+  | 'openai/gpt-3.5-turbo'
+  | 'openai/gpt-3.5-turbo-instruct'
+  | 'openai/gpt-4-turbo'
+  | 'openai/gpt-4.1'
+  | 'openai/gpt-4.1-mini'
+  | 'openai/gpt-4.1-nano'
+  | 'openai/gpt-4o'
+  | 'openai/gpt-4o-mini'
+  | 'openai/gpt-5'
+  | 'openai/gpt-5-chat'
+  | 'openai/gpt-5-codex'
+  | 'openai/gpt-5-mini'
+  | 'openai/gpt-5-nano'
+  | 'openai/gpt-5-pro'
+  | 'openai/gpt-5.1-codex'
+  | 'openai/gpt-5.1-codex-max'
+  | 'openai/gpt-5.1-codex-mini'
+  | 'openai/gpt-5.1-instant'
+  | 'openai/gpt-5.1-thinking'
+  | 'openai/gpt-5.2'
+  | 'openai/gpt-5.2-chat'
+  | 'openai/gpt-5.2-codex'
+  | 'openai/gpt-5.2-pro'
+  | 'openai/gpt-oss-120b'
+  | 'openai/gpt-oss-20b'
+  | 'openai/gpt-oss-safeguard-20b'
+  | 'openai/o1'
+  | 'openai/o3'
+  | 'openai/o3-deep-research'
+  | 'openai/o3-mini'
+  | 'openai/o3-pro'
+  | 'openai/o4-mini'
+  | 'perplexity/sonar'
+  | 'perplexity/sonar-pro'
+  | 'perplexity/sonar-reasoning'
+  | 'perplexity/sonar-reasoning-pro'
+  | 'prime-intellect/intellect-3'
+  | 'stealth/sonoma-dusk-alpha'
+  | 'stealth/sonoma-sky-alpha'
+  | 'vercel/v0-1.0-md'
+  | 'vercel/v0-1.5-md'
+  | 'xai/grok-2-vision'
+  | 'xai/grok-3'
+  | 'xai/grok-3-fast'
+  | 'xai/grok-3-mini'
+  | 'xai/grok-3-mini-fast'
+  | 'xai/grok-4'
+  | 'xai/grok-4-fast-non-reasoning'
+  | 'xai/grok-4-fast-reasoning'
+  | 'xai/grok-4.1-fast-non-reasoning'
+  | 'xai/grok-4.1-fast-reasoning'
+  | 'xai/grok-code-fast-1'
+  | 'xiaomi/mimo-v2-flash'
+  | 'zai/glm-4.5'
+  | 'zai/glm-4.5-air'
+  | 'zai/glm-4.5v'
+  | 'zai/glm-4.6'
+  | 'zai/glm-4.6v'
+  | 'zai/glm-4.6v-flash'
+  | 'zai/glm-4.7'
+  | 'zai/glm-4.7-flashx'
+  | (string & {});

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),
+    };
+  }
+}