ima2-gen 2.0.5 → 2.0.13

package/node_modules/@ai-sdk/gateway/src/errors/index.ts

@@ -0,0 +1,17 @@
+export { asGatewayError } from './as-gateway-error';
+export {
+  createGatewayErrorFromResponse,
+  type GatewayErrorResponse,
+} from './create-gateway-error';
+export { extractApiCallResponse } from './extract-api-call-response';
+export { GatewayError } from './gateway-error';
+export { GatewayAuthenticationError } from './gateway-authentication-error';
+export { GatewayInternalServerError } from './gateway-internal-server-error';
+export { GatewayInvalidRequestError } from './gateway-invalid-request-error';
+export {
+  GatewayModelNotFoundError,
+  modelNotFoundParamSchema,
+} from './gateway-model-not-found-error';
+export { GatewayRateLimitError } from './gateway-rate-limit-error';
+export { GatewayResponseError } from './gateway-response-error';
+export { GatewayTimeoutError } from './gateway-timeout-error';

package/node_modules/@ai-sdk/gateway/src/errors/parse-auth-method.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod/v4';
+import {
+  lazySchema,
+  safeValidateTypes,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+
+export const GATEWAY_AUTH_METHOD_HEADER = 'ai-gateway-auth-method' as const;
+
+export async function parseAuthMethod(
+  headers: Record<string, string | undefined>,
+) {
+  const result = await safeValidateTypes({
+    value: headers[GATEWAY_AUTH_METHOD_HEADER],
+    schema: gatewayAuthMethodSchema,
+  });
+
+  return result.success ? result.value : undefined;
+}
+
+const gatewayAuthMethodSchema = lazySchema(() =>
+  zodSchema(z.union([z.literal('api-key'), z.literal('oidc')])),
+);

package/node_modules/@ai-sdk/gateway/src/gateway-config.ts

@@ -0,0 +1,7 @@
+import type { FetchFunction, Resolvable } from '@ai-sdk/provider-utils';
+
+export type GatewayConfig = {
+  baseURL: string;
+  headers: () => Resolvable<Record<string, string | undefined>>;
+  fetch?: FetchFunction;
+};

package/node_modules/@ai-sdk/gateway/src/gateway-embedding-model-settings.ts

@@ -0,0 +1,25 @@
+export type GatewayEmbeddingModelId =
+  | 'alibaba/qwen3-embedding-0.6b'
+  | 'alibaba/qwen3-embedding-4b'
+  | 'alibaba/qwen3-embedding-8b'
+  | 'amazon/titan-embed-text-v2'
+  | 'cohere/embed-v4.0'
+  | 'google/gemini-embedding-001'
+  | 'google/text-embedding-005'
+  | 'google/text-multilingual-embedding-002'
+  | 'mistral/codestral-embed'
+  | 'mistral/mistral-embed'
+  | 'openai/text-embedding-3-large'
+  | 'openai/text-embedding-3-small'
+  | 'openai/text-embedding-ada-002'
+  | 'voyage/voyage-3-large'
+  | 'voyage/voyage-3.5'
+  | 'voyage/voyage-3.5-lite'
+  | 'voyage/voyage-4'
+  | 'voyage/voyage-4-large'
+  | 'voyage/voyage-4-lite'
+  | 'voyage/voyage-code-2'
+  | 'voyage/voyage-code-3'
+  | 'voyage/voyage-finance-2'
+  | 'voyage/voyage-law-2'
+  | (string & {});

package/node_modules/@ai-sdk/gateway/src/gateway-embedding-model.ts

@@ -0,0 +1,109 @@
+import type {
+  EmbeddingModelV3,
+  SharedV3ProviderMetadata,
+} 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 GatewayEmbeddingModel implements EmbeddingModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly maxEmbeddingsPerCall = 2048;
+  readonly supportsParallelCalls = true;
+
+  constructor(
+    readonly modelId: string,
+    private readonly config: GatewayConfig & {
+      provider: string;
+      o11yHeaders: Resolvable<Record<string, string>>;
+    },
+  ) {}
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions,
+  }: Parameters<EmbeddingModelV3['doEmbed']>[0]): Promise<
+    Awaited<ReturnType<EmbeddingModelV3['doEmbed']>>
+  > {
+    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: {
+          values,
+          ...(providerOptions ? { providerOptions } : {}),
+        },
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayEmbeddingResponseSchema,
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z.any(),
+          errorToMessage: data => data,
+        }),
+        ...(abortSignal && { abortSignal }),
+        fetch: this.config.fetch,
+      });
+
+      return {
+        embeddings: responseBody.embeddings,
+        usage: responseBody.usage ?? undefined,
+        providerMetadata:
+          responseBody.providerMetadata as unknown as SharedV3ProviderMetadata,
+        response: { headers: responseHeaders, body: rawValue },
+        warnings: [],
+      };
+    } catch (error) {
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+
+  private getUrl() {
+    return `${this.config.baseURL}/embedding-model`;
+  }
+
+  private getModelConfigHeaders() {
+    return {
+      'ai-embedding-model-specification-version': '3',
+      'ai-model-id': this.modelId,
+    };
+  }
+}
+
+const gatewayEmbeddingResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      embeddings: z.array(z.array(z.number())),
+      usage: z.object({ tokens: z.number() }).nullish(),
+      providerMetadata: z
+        .record(z.string(), z.record(z.string(), z.unknown()))
+        .optional(),
+    }),
+  ),
+);

package/node_modules/@ai-sdk/gateway/src/gateway-fetch-metadata.ts

@@ -0,0 +1,129 @@
+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(['embedding', 'image', 'language', 'video'])
+            .nullish(),
+        }),
+      ),
+    }),
+  ),
+);
+
+const gatewayCreditsResponseSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        balance: z.string(),
+        total_used: z.string(),
+      })
+      .transform(({ balance, total_used }) => ({
+        balance,
+        totalUsed: total_used,
+      })),
+  ),
+);

package/node_modules/@ai-sdk/gateway/src/gateway-image-model-settings.ts

@@ -0,0 +1,19 @@
+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'
+  | 'openai/gpt-image-1'
+  | 'openai/gpt-image-1-mini'
+  | 'openai/gpt-image-1.5'
+  | 'recraft/recraft-v2'
+  | 'recraft/recraft-v3'
+  | 'recraft/recraft-v4'
+  | 'recraft/recraft-v4-pro'
+  | 'xai/grok-imagine-image'
+  | 'xai/grok-imagine-image-pro'
+  | (string & {});

package/node_modules/@ai-sdk/gateway/src/gateway-image-model.ts

@@ -0,0 +1,169 @@
+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,
+        },
+        ...(responseBody.usage != null && {
+          usage: {
+            inputTokens: responseBody.usage.inputTokens ?? undefined,
+            outputTokens: responseBody.usage.outputTokens ?? undefined,
+            totalTokens: responseBody.usage.totalTokens ?? undefined,
+          },
+        }),
+      };
+    } catch (error) {
+      throw await 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 gatewayImageWarningSchema = 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('other'),
+    message: z.string(),
+  }),
+]);
+
+const gatewayImageUsageSchema = z.object({
+  inputTokens: z.number().nullish(),
+  outputTokens: z.number().nullish(),
+  totalTokens: z.number().nullish(),
+});
+
+const gatewayImageResponseSchema = z.object({
+  images: z.array(z.string()), // Always base64 strings over the wire
+  warnings: z.array(gatewayImageWarningSchema).optional(),
+  providerMetadata: z
+    .record(z.string(), providerMetadataEntrySchema)
+    .optional(),
+  usage: gatewayImageUsageSchema.optional(),
+});

package/node_modules/@ai-sdk/gateway/src/gateway-language-model-settings.ts

@@ -0,0 +1,171 @@
+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-next'
+  | 'alibaba/qwen3-coder-plus'
+  | 'alibaba/qwen3-max'
+  | 'alibaba/qwen3-max-preview'
+  | 'alibaba/qwen3-max-thinking'
+  | 'alibaba/qwen3-next-80b-a3b-instruct'
+  | 'alibaba/qwen3-next-80b-a3b-thinking'
+  | 'alibaba/qwen3-vl-instruct'
+  | 'alibaba/qwen3-vl-thinking'
+  | 'alibaba/qwen3.5-flash'
+  | 'alibaba/qwen3.5-plus'
+  | '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-opus-4.6'
+  | 'anthropic/claude-sonnet-4'
+  | 'anthropic/claude-sonnet-4.5'
+  | 'anthropic/claude-sonnet-4.6'
+  | 'arcee-ai/trinity-large-preview'
+  | '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-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-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'
+  | 'google/gemini-3.1-flash-image-preview'
+  | 'google/gemini-3.1-flash-lite-preview'
+  | 'google/gemini-3.1-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'
+  | 'minimax/minimax-m2.5'
+  | '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'
+  | 'moonshotai/kimi-k2.5'
+  | '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-4o-mini-search-preview'
+  | '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-5.3-chat'
+  | 'openai/gpt-5.3-codex'
+  | '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'
+  | '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'
+  | 'zai/glm-5'
+  | (string & {});