@ai-sdk/alibaba 0.0.0-6b196531-20260710185421

package/src/alibaba-embedding-model.ts

@@ -0,0 +1,178 @@
+import {
+  TooManyEmbeddingValuesForCallError,
+  UnsupportedFunctionalityError,
+  type EmbeddingModelV4,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  parseProviderOptions,
+  postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import {
+  alibabaEmbeddingModelOptions,
+  type AlibabaEmbeddingModelId,
+} from './alibaba-embedding-model-options';
+import type { AlibabaConfig } from './alibaba-config';
+
+// TODO: Add Alibaba multimodal embedding support in a follow-up change.
+const alibabaEmbeddingFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: z.object({
+    code: z.string().nullish(),
+    message: z.string(),
+    request_id: z.string().nullish(),
+  }),
+  errorToMessage: data => data.message,
+});
+
+export class AlibabaEmbeddingModel implements EmbeddingModelV4 {
+  readonly specificationVersion = 'v4';
+  readonly modelId: AlibabaEmbeddingModelId;
+  readonly maxEmbeddingsPerCall = 10;
+  readonly supportsParallelCalls = false;
+
+  private readonly config: AlibabaConfig;
+
+  static [WORKFLOW_SERIALIZE](model: AlibabaEmbeddingModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: AlibabaEmbeddingModelId;
+    config: AlibabaConfig;
+  }) {
+    return new AlibabaEmbeddingModel(options.modelId, options.config);
+  }
+
+  constructor(modelId: AlibabaEmbeddingModelId, config: AlibabaConfig) {
+    this.modelId = modelId;
+    this.config = config;
+  }
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions,
+  }: Parameters<EmbeddingModelV4['doEmbed']>[0]): Promise<
+    Awaited<ReturnType<EmbeddingModelV4['doEmbed']>>
+  > {
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values,
+      });
+    }
+
+    const alibabaOptions = await parseProviderOptions({
+      provider: 'alibaba',
+      providerOptions,
+      schema: alibabaEmbeddingModelOptions,
+    });
+
+    // TODO: Explore first-class sparse embedding support in AI SDK core.
+    if (alibabaOptions?.outputType === 'sparse') {
+      throw new UnsupportedFunctionalityError({
+        functionality: "Alibaba embedding outputType 'sparse'",
+        message:
+          "Alibaba embedding outputType 'sparse' is not supported because AI SDK embeddings require dense number arrays. Use 'dense' or 'dense&sparse' instead.",
+      });
+    }
+
+    const {
+      responseHeaders,
+      value: response,
+      rawValue,
+    } = await postJsonToApi({
+      url: `${this.config.baseURL}/services/embeddings/text-embedding/text-embedding`,
+      headers: combineHeaders(this.config.headers?.(), headers),
+      body: {
+        model: this.modelId,
+        input: {
+          texts: values,
+        },
+        parameters: {
+          text_type: alibabaOptions?.textType,
+          dimension: alibabaOptions?.dimension,
+          output_type: alibabaOptions?.outputType,
+        },
+      },
+      failedResponseHandler: alibabaEmbeddingFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        alibabaTextEmbeddingResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    const sortedEmbeddings = response.output.embeddings.sort(
+      (a, b) => a.text_index - b.text_index,
+    );
+    const sparseEmbeddings = sortedEmbeddings
+      .map(item =>
+        item.sparse_embedding == null
+          ? undefined
+          : {
+              textIndex: item.text_index,
+              sparseEmbedding: item.sparse_embedding,
+            },
+      )
+      .filter(item => item != null);
+
+    return {
+      warnings: [],
+      embeddings: sortedEmbeddings.map(item => item.embedding),
+      usage: response.usage
+        ? { tokens: response.usage.total_tokens }
+        : undefined,
+      providerMetadata:
+        sparseEmbeddings.length > 0
+          ? {
+              alibaba: {
+                sparseEmbeddings,
+              },
+            }
+          : undefined,
+      response: { headers: responseHeaders, body: rawValue },
+    };
+  }
+}
+
+const alibabaTextEmbeddingSparseEmbeddingSchema = z.object({
+  index: z.number(),
+  value: z.number(),
+  token: z.string().nullish(),
+});
+
+const alibabaTextEmbeddingResponseSchema = z.object({
+  output: z.object({
+    embeddings: z.array(
+      z.object({
+        embedding: z.array(z.number()),
+        text_index: z.number(),
+        sparse_embedding: z
+          .array(alibabaTextEmbeddingSparseEmbeddingSchema)
+          .nullish(),
+      }),
+    ),
+  }),
+  usage: z
+    .object({
+      total_tokens: z.number(),
+    })
+    .nullish(),
+});

package/src/alibaba-error.ts

@@ -0,0 +1,17 @@
+import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+const alibabaErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    code: z.string().nullish(),
+    type: z.string().nullish(),
+  }),
+});
+
+export type AlibabaErrorData = z.infer<typeof alibabaErrorDataSchema>;
+
+export const alibabaFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: alibabaErrorDataSchema,
+  errorToMessage: data => data.error.message,
+});

package/src/alibaba-provider.ts

@@ -0,0 +1,187 @@
+import {
+  NoSuchModelError,
+  type EmbeddingModelV4,
+  type Experimental_VideoModelV4,
+  type LanguageModelV4,
+  type ProviderV4,
+} from '@ai-sdk/provider';
+import {
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
+import { AlibabaChatLanguageModel } from './alibaba-chat-language-model';
+import type { AlibabaChatModelId } from './alibaba-chat-language-model-options';
+import { AlibabaEmbeddingModel } from './alibaba-embedding-model';
+import type { AlibabaEmbeddingModelId } from './alibaba-embedding-model-options';
+import { AlibabaVideoModel } from './alibaba-video-model';
+import type { AlibabaVideoModelId } from './alibaba-video-settings';
+import { VERSION } from './version';
+
+export type { AlibabaErrorData } from './alibaba-error';
+export { alibabaFailedResponseHandler } from './alibaba-error';
+
+export interface AlibabaProvider extends ProviderV4 {
+  (modelId: AlibabaChatModelId): LanguageModelV4;
+
+  /**
+   * Creates a model for text generation.
+   */
+  languageModel(modelId: AlibabaChatModelId): LanguageModelV4;
+
+  /**
+   * Creates a chat model for text generation.
+   */
+  chatModel(modelId: AlibabaChatModelId): LanguageModelV4;
+
+  /**
+   * Creates a model for text embeddings.
+   */
+  embedding(modelId: AlibabaEmbeddingModelId): EmbeddingModelV4;
+
+  /**
+   * Creates a model for text embeddings.
+   */
+  embeddingModel(modelId: AlibabaEmbeddingModelId): EmbeddingModelV4;
+
+  /**
+   * Creates a model for video generation.
+   */
+  video(modelId: AlibabaVideoModelId): Experimental_VideoModelV4;
+
+  /**
+   * Creates a model for video generation.
+   */
+  videoModel(modelId: AlibabaVideoModelId): Experimental_VideoModelV4;
+}
+
+export interface AlibabaProviderSettings {
+  /**
+   * Use a different URL prefix for API calls, e.g. to use proxy servers or regional endpoints.
+   * The default prefix is `https://dashscope-intl.aliyuncs.com/compatible-mode/v1`.
+   */
+  baseURL?: string;
+
+  /**
+   * Use a different URL prefix for video generation API calls.
+   * The video API uses the DashScope native endpoint (not the OpenAI-compatible endpoint).
+   * The default prefix is `https://dashscope-intl.aliyuncs.com`.
+   */
+  videoBaseURL?: string;
+
+  /**
+   * Use a different URL prefix for embedding API calls.
+   * The embedding API uses the DashScope native endpoint (not the OpenAI-compatible endpoint).
+   * The default prefix is `https://dashscope-intl.aliyuncs.com/api/v1`.
+   */
+  embeddingBaseURL?: string;
+
+  /**
+   * API key that is being sent using the `Authorization` header.
+   * It defaults to the `ALIBABA_API_KEY` environment variable.
+   */
+  apiKey?: string;
+
+  /**
+   * Custom headers to include in the requests.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * Custom fetch implementation. You can use it as a middleware to intercept requests,
+   * or to provide a custom fetch implementation for e.g. testing.
+   */
+  fetch?: FetchFunction;
+
+  /**
+   * Include usage information in streaming responses.
+   * When enabled, token usage will be included in the final chunk.
+   *
+   * @default true
+   */
+  includeUsage?: boolean;
+}
+
+/**
+ * Create an Alibaba Cloud (Qwen) provider instance.
+ */
+export function createAlibaba(
+  options: AlibabaProviderSettings = {},
+): AlibabaProvider {
+  const baseURL =
+    withoutTrailingSlash(options.baseURL) ??
+    'https://dashscope-intl.aliyuncs.com/compatible-mode/v1';
+
+  const videoBaseURL =
+    withoutTrailingSlash(options.videoBaseURL) ??
+    'https://dashscope-intl.aliyuncs.com';
+
+  const embeddingBaseURL =
+    withoutTrailingSlash(options.embeddingBaseURL) ??
+    'https://dashscope-intl.aliyuncs.com/api/v1';
+
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'ALIBABA_API_KEY',
+          description: 'Alibaba Cloud (DashScope)',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/alibaba/${VERSION}`,
+    );
+
+  const createLanguageModel = (modelId: AlibabaChatModelId) =>
+    new AlibabaChatLanguageModel(modelId, {
+      provider: 'alibaba.chat',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      includeUsage: options.includeUsage ?? true,
+    });
+
+  const createEmbeddingModel = (modelId: AlibabaEmbeddingModelId) =>
+    new AlibabaEmbeddingModel(modelId, {
+      provider: 'alibaba.embedding',
+      baseURL: embeddingBaseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const createVideoModel = (modelId: AlibabaVideoModelId) =>
+    new AlibabaVideoModel(modelId, {
+      provider: 'alibaba.video',
+      baseURL: videoBaseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const provider = function (modelId: AlibabaChatModelId) {
+    if (new.target) {
+      throw new Error(
+        'The Alibaba model function cannot be called with the new keyword.',
+      );
+    }
+
+    return createLanguageModel(modelId);
+  };
+
+  provider.specificationVersion = 'v4' as const;
+  provider.languageModel = createLanguageModel;
+  provider.chatModel = createLanguageModel;
+  provider.embedding = createEmbeddingModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.video = createVideoModel;
+  provider.videoModel = createVideoModel;
+
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+  };
+
+  return provider;
+}
+
+export const alibaba = createAlibaba();

package/src/alibaba-video-model-options.ts

@@ -0,0 +1,77 @@
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export type AlibabaVideoModelOptions = {
+  /** Negative prompt to specify what to avoid (max 500 chars). */
+  negativePrompt?: string | null;
+  /** URL to audio file for audio-video sync (WAV/MP3, 3-30s, max 15MB). */
+  audioUrl?: string | null;
+  /** Enable prompt extension/rewriting for better generation. Defaults to true. */
+  promptExtend?: boolean | null;
+  /**
+   * Shot type: 'single' for single-shot or 'multi' for multi-shot narrative
+   * (wan2.6 and earlier; wan2.7 models describe shot structure in the prompt).
+   */
+  shotType?: 'single' | 'multi' | null;
+  /** Whether to add watermark to generated video. Defaults to false. */
+  watermark?: boolean | null;
+  /**
+   * Enable audio generation (for wan2.6 I2V/R2V models;
+   * wan2.7 models always generate audio).
+   */
+  audio?: boolean | null;
+  /**
+   * Reference URLs for reference-to-video mode (wan2.6 models).
+   * Array of URLs to images (0-5) and/or videos (0-3), max 5 total.
+   * Use character identifiers (character1, character2) in prompts to reference them.
+   */
+  referenceUrls?: string[] | null;
+  /**
+   * Explicit media array for reference-to-video mode (wan2.7 models).
+   * Overrides the automatic mapping from `inputReferences` and `frameImages`.
+   * Use `Image 1`, `Video 1`, etc. in prompts to reference media items
+   * (images and videos are counted separately, in array order).
+   */
+  media?: Array<{
+    type: 'reference_image' | 'reference_video' | 'first_frame';
+    /** Public URL, or a `data:{mime};base64,{data}` URI for images. */
+    url: string;
+    /** URL to an audio file used as voice reference for this media item. */
+    referenceVoice?: string | null;
+  }> | null;
+  /**
+   * Aspect ratio (wan2.7 text-to-video and reference-to-video models).
+   */
+  ratio?: '16:9' | '9:16' | '1:1' | '4:3' | '3:4' | null;
+  /** Polling interval in milliseconds. Defaults to 5000 (5 seconds). */
+  pollIntervalMs?: number | null;
+  /** Maximum wait time in milliseconds for video generation. Defaults to 600000 (10 minutes). */
+  pollTimeoutMs?: number | null;
+  [key: string]: unknown;
+};
+
+export const alibabaVideoModelOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.looseObject({
+      negativePrompt: z.string().nullish(),
+      audioUrl: z.string().nullish(),
+      promptExtend: z.boolean().nullish(),
+      shotType: z.enum(['single', 'multi']).nullish(),
+      watermark: z.boolean().nullish(),
+      audio: z.boolean().nullish(),
+      referenceUrls: z.array(z.string()).nullish(),
+      media: z
+        .array(
+          z.object({
+            type: z.enum(['reference_image', 'reference_video', 'first_frame']),
+            url: z.string(),
+            referenceVoice: z.string().nullish(),
+          }),
+        )
+        .nullish(),
+      ratio: z.enum(['16:9', '9:16', '1:1', '4:3', '3:4']).nullish(),
+      pollIntervalMs: z.number().positive().nullish(),
+      pollTimeoutMs: z.number().positive().nullish(),
+    }),
+  ),
+);