@ai-sdk/zai 0.0.0 → 1.0.2

package/src/zai-chat-language-model.ts

@@ -0,0 +1,252 @@
+import { OpenAICompatibleChatLanguageModel } from '@ai-sdk/openai-compatible';
+import type {
+  LanguageModelV2,
+  LanguageModelV2CallOptions,
+  LanguageModelV2CallWarning,
+  LanguageModelV2FinishReason,
+  LanguageModelV2StreamPart,
+} from '@ai-sdk/provider';
+import {
+  parseProviderOptions,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
+import type { ZaiChatModelId } from './zai-chat-options';
+import { zaiLanguageModelChatOptions } from './zai-chat-language-model-options';
+import { zaiErrorStructure } from './zai-error';
+
+export type ZaiChatConfig = {
+  provider: string;
+  baseURL: string;
+  headers?:
+    | Record<string, string | undefined>
+    | (() => Record<string, string | undefined>);
+  fetch?: FetchFunction;
+};
+
+function transformZaiRequestBody(
+  args: Record<string, any>,
+): Record<string, any> {
+  const {
+    doSample,
+    frequency_penalty: _frequencyPenalty,
+    presence_penalty: _presencePenalty,
+    requestId,
+    seed: _seed,
+    thinking,
+    toolStream,
+    user: _user,
+    userId,
+    verbosity: _verbosity,
+    ...restArgs
+  } = args;
+
+  return {
+    ...restArgs,
+    ...(doSample !== undefined && { do_sample: doSample }),
+    ...(thinking !== undefined && {
+      thinking: {
+        ...(thinking.type !== undefined && { type: thinking.type }),
+        ...(thinking.clearThinking !== undefined && {
+          clear_thinking: thinking.clearThinking,
+        }),
+      },
+    }),
+    ...(toolStream !== undefined && { tool_stream: toolStream }),
+    ...(requestId !== undefined && { request_id: requestId }),
+    ...(userId !== undefined && { user_id: userId }),
+  };
+}
+
+function mapZaiFinishReason(
+  finishReason: LanguageModelV2FinishReason,
+  rawFinishReason: string | undefined,
+): LanguageModelV2FinishReason {
+  switch (rawFinishReason) {
+    case 'sensitive':
+      return 'content-filter';
+    case 'model_context_window_exceeded':
+      return 'length';
+    case 'network_error':
+      return 'error';
+    default:
+      return finishReason;
+  }
+}
+
+function getRawFinishReason(responseBody: unknown): string | undefined {
+  if (responseBody == null || typeof responseBody !== 'object') {
+    return undefined;
+  }
+
+  const choices = (responseBody as { choices?: unknown }).choices;
+  if (!Array.isArray(choices) || choices.length === 0) {
+    return undefined;
+  }
+
+  const choice = choices[0];
+  if (choice == null || typeof choice !== 'object') {
+    return undefined;
+  }
+
+  const finishReason = (choice as { finish_reason?: unknown }).finish_reason;
+  return typeof finishReason === 'string' ? finishReason : undefined;
+}
+
+export class ZaiChatLanguageModel
+  extends OpenAICompatibleChatLanguageModel
+  implements LanguageModelV2
+{
+  constructor(modelId: ZaiChatModelId, config: ZaiChatConfig) {
+    const headers = config.headers;
+
+    super(modelId, {
+      provider: config.provider,
+      url: ({ path }) => `${config.baseURL}${path}`,
+      headers: () =>
+        headers == null
+          ? {}
+          : typeof headers === 'function'
+            ? headers()
+            : headers,
+      fetch: config.fetch,
+      errorStructure: zaiErrorStructure,
+      transformRequestBody: transformZaiRequestBody,
+      supportedUrls: () => ({
+        'image/*': [/^https?:\/\//],
+        'video/*': [/^https?:\/\//],
+      }),
+    });
+  }
+
+  private async prepareCallOptions(options: LanguageModelV2CallOptions) {
+    const warnings: LanguageModelV2CallWarning[] = [];
+
+    const zaiOptions = await parseProviderOptions({
+      provider: 'zai',
+      providerOptions: options.providerOptions,
+      schema: zaiLanguageModelChatOptions,
+    });
+
+    if (options.frequencyPenalty != null) {
+      warnings.push({
+        type: 'unsupported-setting',
+        setting: 'frequencyPenalty',
+      });
+    }
+    if (options.presencePenalty != null) {
+      warnings.push({
+        type: 'unsupported-setting',
+        setting: 'presencePenalty',
+      });
+    }
+    if (options.seed != null) {
+      warnings.push({ type: 'unsupported-setting', setting: 'seed' });
+    }
+
+    let tools = options.tools;
+    let toolChoice = options.toolChoice;
+
+    if (toolChoice?.type === 'none') {
+      tools = undefined;
+      toolChoice = undefined;
+    } else if (toolChoice != null && toolChoice.type !== 'auto') {
+      warnings.push({
+        type: 'unsupported-setting',
+        setting: 'toolChoice',
+        details: 'Z.AI currently supports only automatic tool selection.',
+      });
+      toolChoice = undefined;
+    }
+
+    const normalizedOptions: LanguageModelV2CallOptions = {
+      ...options,
+      frequencyPenalty: undefined,
+      presencePenalty: undefined,
+      seed: undefined,
+      tools,
+      toolChoice,
+      providerOptions:
+        zaiOptions == null
+          ? options.providerOptions
+          : {
+              ...options.providerOptions,
+              zai: zaiOptions,
+            },
+    };
+
+    return { normalizedOptions, warnings };
+  }
+
+  async doGenerate(
+    options: Parameters<LanguageModelV2['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<LanguageModelV2['doGenerate']>>> {
+    const { normalizedOptions, warnings } =
+      await this.prepareCallOptions(options);
+    const result = await super.doGenerate(normalizedOptions);
+
+    return {
+      ...result,
+      finishReason: mapZaiFinishReason(
+        result.finishReason,
+        getRawFinishReason(result.response?.body),
+      ),
+      warnings: [...result.warnings, ...warnings],
+    };
+  }
+
+  async doStream(
+    options: Parameters<LanguageModelV2['doStream']>[0],
+  ): Promise<Awaited<ReturnType<LanguageModelV2['doStream']>>> {
+    const originalIncludeRawChunks = options.includeRawChunks;
+    const { normalizedOptions, warnings } =
+      await this.prepareCallOptions(options);
+    const result = await super.doStream({
+      ...normalizedOptions,
+      includeRawChunks: true,
+    });
+
+    let rawFinishReason: string | undefined;
+
+    return {
+      ...result,
+      stream: result.stream.pipeThrough(
+        new TransformStream<
+          LanguageModelV2StreamPart,
+          LanguageModelV2StreamPart
+        >({
+          transform(part, controller) {
+            if (part.type === 'stream-start') {
+              controller.enqueue({
+                ...part,
+                warnings: [...part.warnings, ...warnings],
+              });
+              return;
+            }
+
+            if (part.type === 'raw') {
+              rawFinishReason =
+                getRawFinishReason(part.rawValue) ?? rawFinishReason;
+              if (originalIncludeRawChunks) {
+                controller.enqueue(part);
+              }
+              return;
+            }
+
+            if (part.type === 'finish') {
+              controller.enqueue({
+                ...part,
+                finishReason: mapZaiFinishReason(
+                  part.finishReason,
+                  rawFinishReason,
+                ),
+              });
+              return;
+            }
+
+            controller.enqueue(part);
+          },
+        }),
+      ),
+    };
+  }
+}

package/src/zai-chat-options.ts

@@ -0,0 +1,28 @@
+/**
+ * Z.AI chat model ids from the official OpenAPI 1.0.0 specification,
+ * retrieved from https://docs.z.ai/openapi.json on 2026-08-26.
+ */
+export type ZaiChatModelId =
+  | 'glm-5.3'
+  | 'glm-5.2'
+  | 'glm-5.1'
+  | 'glm-5-turbo'
+  | 'glm-5'
+  | 'glm-4.7'
+  | 'glm-4.7-flash'
+  | 'glm-4.7-flashx'
+  | 'glm-4.6'
+  | 'glm-4.5'
+  | 'glm-4.5-air'
+  | 'glm-4.5-x'
+  | 'glm-4.5-airx'
+  | 'glm-4.5-flash'
+  | 'glm-4-32b-0414-128k'
+  | 'glm-5.3-flash'
+  | 'glm-5v-turbo'
+  | 'glm-4.6v'
+  | 'glm-4.6v-flash'
+  | 'glm-4.6v-flashx'
+  | 'glm-4.5v'
+  | 'autoglm-phone-multilingual'
+  | (string & {});

package/src/zai-error.ts

@@ -0,0 +1,19 @@
+import type { ProviderErrorStructure } from '@ai-sdk/openai-compatible';
+import { z } from 'zod/v4';
+
+const zaiErrorDetailsSchema = z.object({
+  code: z.union([z.number(), z.string()]).nullish(),
+  message: z.string(),
+});
+
+const zaiErrorSchema = z.union([
+  zaiErrorDetailsSchema,
+  z.object({ error: zaiErrorDetailsSchema }),
+]);
+
+export type ZaiErrorData = z.infer<typeof zaiErrorSchema>;
+
+export const zaiErrorStructure: ProviderErrorStructure<ZaiErrorData> = {
+  errorSchema: zaiErrorSchema,
+  errorToMessage: data => ('error' in data ? data.error.message : data.message),
+};

package/src/zai-provider.ts

@@ -0,0 +1,103 @@
+import {
+  NoSuchModelError,
+  type LanguageModelV2,
+  type ProviderV2,
+} from '@ai-sdk/provider';
+import {
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
+import { VERSION } from './version';
+import { ZaiChatLanguageModel } from './zai-chat-language-model';
+import type { ZaiChatModelId } from './zai-chat-options';
+
+export interface ZaiProviderSettings {
+  /**
+   * Z.AI API key. Defaults to the `ZAI_API_KEY` environment variable.
+   */
+  apiKey?: string;
+
+  /**
+   * Base URL for API calls. Defaults to
+   * `https://api.z.ai/api/paas/v4`.
+   */
+  baseURL?: string;
+
+  /**
+   * Custom headers to include in requests.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * Custom fetch implementation.
+   */
+  fetch?: FetchFunction;
+}
+
+export interface ZaiProvider extends ProviderV2 {
+  /**
+   * Creates a Z.AI chat model for text generation.
+   */
+  (modelId: ZaiChatModelId): LanguageModelV2;
+
+  /**
+   * Creates a Z.AI language model.
+   */
+  languageModel(modelId: ZaiChatModelId): LanguageModelV2;
+
+  /**
+   * Creates a Z.AI chat model.
+   */
+  chatModel(modelId: ZaiChatModelId): LanguageModelV2;
+
+  /**
+   * Creates a Z.AI chat model.
+   */
+  chat(modelId: ZaiChatModelId): LanguageModelV2;
+}
+
+export function createZai(options: ZaiProviderSettings = {}): ZaiProvider {
+  const baseURL =
+    withoutTrailingSlash(options.baseURL) ?? 'https://api.z.ai/api/paas/v4';
+
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'ZAI_API_KEY',
+          description: 'Z.AI API key',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/zai/${VERSION}`,
+    );
+
+  const createLanguageModel = (modelId: ZaiChatModelId) =>
+    new ZaiChatLanguageModel(modelId, {
+      provider: 'zai.chat',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const provider = (modelId: ZaiChatModelId) => createLanguageModel(modelId);
+
+  provider.specificationVersion = 'v2' as const;
+  provider.languageModel = createLanguageModel;
+  provider.chatModel = createLanguageModel;
+  provider.chat = createLanguageModel;
+
+  provider.textEmbeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'textEmbeddingModel' });
+  };
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+  };
+
+  return provider;
+}
+
+export const zai = createZai();

package/index.js

@@ -1 +0,0 @@
-export {};