@ai-sdk/alibaba 1.0.0

package/src/alibaba-chat-prompt.ts

@@ -0,0 +1,63 @@
+export type AlibabaCacheControl = { type: string };
+
+export type AlibabaChatPrompt = Array<AlibabaChatMessage>;
+
+export type AlibabaChatMessage =
+  | AlibabaChatSystemMessage
+  | AlibabaChatUserMessage
+  | AlibabaChatAssistantMessage
+  | AlibabaChatToolMessage;
+
+export interface AlibabaChatSystemMessage {
+  role: 'system';
+  content: string | Array<AlibabaChatSystemMessageContent>;
+}
+
+export type AlibabaChatSystemMessageContent = {
+  type: 'text';
+  text: string;
+  cache_control?: AlibabaCacheControl;
+};
+
+export interface AlibabaChatUserMessage {
+  role: 'user';
+  content: string | Array<AlibabaChatUserMessageContent>;
+}
+
+export type AlibabaChatUserMessageContent =
+  | { type: 'text'; text: string; cache_control?: AlibabaCacheControl }
+  | { type: 'image_url'; image_url: { url: string } };
+
+export interface AlibabaChatAssistantMessage {
+  role: 'assistant';
+  content: string | null | Array<AlibabaChatAssistantMessageContent>;
+  tool_calls?: Array<{
+    id: string;
+    type: 'function';
+    function: { name: string; arguments: string };
+  }>;
+}
+
+export type AlibabaChatAssistantMessageContent = {
+  type: 'text';
+  text: string;
+  cache_control?: AlibabaCacheControl;
+};
+
+export interface AlibabaChatToolMessage {
+  role: 'tool';
+  tool_call_id: string;
+  content: string | Array<AlibabaChatToolMessageContent>;
+}
+
+export type AlibabaChatToolMessageContent = {
+  type: 'text';
+  text: string;
+  cache_control?: AlibabaCacheControl;
+};
+
+export type AlibabaChatToolChoice =
+  | { type: 'function'; function: { name: string } }
+  | 'auto'
+  | 'none'
+  | 'required';

package/src/alibaba-config.ts

@@ -0,0 +1,9 @@
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+export interface AlibabaConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  includeUsage?: boolean;
+}

package/src/alibaba-provider.ts

@@ -0,0 +1,137 @@
+import {
+  LanguageModelV3,
+  NoSuchModelError,
+  ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  createJsonErrorResponseHandler,
+  FetchFunction,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { AlibabaLanguageModel } from './alibaba-chat-language-model';
+import { AlibabaChatModelId } from './alibaba-chat-options';
+import { VERSION } from './version';
+
+export type AlibabaErrorData = z.infer<typeof alibabaErrorDataSchema>;
+
+const alibabaErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    code: z.string().nullish(),
+    type: z.string().nullish(),
+  }),
+});
+
+export const alibabaFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: alibabaErrorDataSchema,
+  errorToMessage: data => data.error.message,
+});
+
+export interface AlibabaProvider extends ProviderV3 {
+  (modelId: AlibabaChatModelId): LanguageModelV3;
+
+  /**
+   * Creates a model for text generation.
+   */
+  languageModel(modelId: AlibabaChatModelId): LanguageModelV3;
+
+  /**
+   * Creates a chat model for text generation.
+   */
+  chatModel(modelId: AlibabaChatModelId): LanguageModelV3;
+}
+
+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;
+
+  /**
+   * 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 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 AlibabaLanguageModel(modelId, {
+      provider: 'alibaba.chat',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      includeUsage: options.includeUsage ?? true,
+    });
+
+  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 = 'v3' as const;
+  provider.languageModel = createLanguageModel;
+  provider.chatModel = createLanguageModel;
+
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+  };
+
+  provider.embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });
+  };
+
+  return provider;
+}
+
+export const alibaba = createAlibaba();

package/src/convert-alibaba-usage.ts

@@ -0,0 +1,37 @@
+import { LanguageModelV3Usage } from '@ai-sdk/provider';
+import { convertOpenAICompatibleChatUsage } from '@ai-sdk/openai-compatible/internal';
+
+export type AlibabaUsage = {
+  prompt_tokens?: number | null;
+  completion_tokens?: number | null;
+  total_tokens?: number | null;
+  prompt_tokens_details?: {
+    cached_tokens?: number | null;
+    cache_creation_input_tokens?: number | null;
+  } | null;
+  completion_tokens_details?: {
+    reasoning_tokens?: number | null;
+  } | null;
+};
+
+export function convertAlibabaUsage(
+  usage: AlibabaUsage | undefined | null,
+): LanguageModelV3Usage {
+  const baseUsage = convertOpenAICompatibleChatUsage(usage);
+
+  const cacheWriteTokens =
+    usage?.prompt_tokens_details?.cache_creation_input_tokens ?? 0;
+  const noCacheTokens =
+    (baseUsage.inputTokens.total ?? 0) -
+    (baseUsage.inputTokens.cacheRead ?? 0) -
+    cacheWriteTokens;
+
+  return {
+    ...baseUsage,
+    inputTokens: {
+      ...baseUsage.inputTokens,
+      cacheWrite: cacheWriteTokens,
+      noCache: noCacheTokens,
+    },
+  };
+}

package/src/convert-to-alibaba-chat-messages.ts

@@ -0,0 +1,183 @@
+import {
+  LanguageModelV3DataContent,
+  LanguageModelV3Prompt,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+import { AlibabaChatPrompt } from './alibaba-chat-prompt';
+import { CacheControlValidator } from './get-cache-control';
+
+function formatImageUrl({
+  data,
+  mediaType,
+}: {
+  data: LanguageModelV3DataContent;
+  mediaType: string;
+}): string {
+  return data instanceof URL
+    ? data.toString()
+    : `data:${mediaType};base64,${convertToBase64(data as Uint8Array)}`;
+}
+
+export function convertToAlibabaChatMessages({
+  prompt,
+  cacheControlValidator,
+}: {
+  prompt: LanguageModelV3Prompt;
+  cacheControlValidator?: CacheControlValidator;
+}): AlibabaChatPrompt {
+  const messages: AlibabaChatPrompt = [];
+
+  for (const { role, content, ...message } of prompt) {
+    switch (role) {
+      case 'system': {
+        const cacheControl = cacheControlValidator?.getCacheControl(
+          message.providerOptions,
+        );
+
+        // If cache_control is present, convert to array format
+        if (cacheControl) {
+          messages.push({
+            role: 'system',
+            content: [
+              {
+                type: 'text',
+                text: content,
+                cache_control: cacheControl,
+              },
+            ],
+          });
+        } else {
+          messages.push({ role: 'system', content });
+        }
+        break;
+      }
+
+      case 'user': {
+        // Single text part -> use string content
+        if (content.length === 1 && content[0].type === 'text') {
+          messages.push({
+            role: 'user',
+            content: content[0].text,
+          });
+          break;
+        }
+
+        // Multi-part content
+        messages.push({
+          role: 'user',
+          content: content.map(part => {
+            switch (part.type) {
+              case 'text': {
+                return { type: 'text', text: part.text };
+              }
+
+              case 'file': {
+                if (part.mediaType.startsWith('image/')) {
+                  const mediaType =
+                    part.mediaType === 'image/*'
+                      ? 'image/jpeg'
+                      : part.mediaType;
+
+                  return {
+                    type: 'image_url',
+                    image_url: {
+                      url: formatImageUrl({ data: part.data, mediaType }),
+                    },
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: 'Only image file parts are supported',
+                  });
+                }
+              }
+            }
+          }),
+        });
+        break;
+      }
+
+      case 'assistant': {
+        let text = '';
+        const toolCalls: Array<{
+          id: string;
+          type: 'function';
+          function: { name: string; arguments: string };
+        }> = [];
+
+        for (const part of content) {
+          switch (part.type) {
+            case 'text': {
+              text += part.text;
+              break;
+            }
+            case 'tool-call': {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: 'function',
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input),
+                },
+              });
+              break;
+            }
+            case 'reasoning': {
+              // Reasoning content is handled separately in the response
+              // but may appear in assistant messages during multi-turn conversations
+              text += part.text;
+              break;
+            }
+          }
+        }
+
+        messages.push({
+          role: 'assistant',
+          content: text || null,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+        });
+
+        break;
+      }
+
+      case 'tool': {
+        for (const toolResponse of content) {
+          if (toolResponse.type === 'tool-approval-response') {
+            continue;
+          }
+          const output = toolResponse.output;
+
+          let contentValue: string;
+          switch (output.type) {
+            case 'text':
+            case 'error-text':
+              contentValue = output.value;
+              break;
+            case 'execution-denied':
+              contentValue = output.reason ?? 'Tool execution denied.';
+              break;
+            case 'content':
+            case 'json':
+            case 'error-json':
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+
+          messages.push({
+            role: 'tool',
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+          });
+        }
+        break;
+      }
+
+      default: {
+        const _exhaustiveCheck: never = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return messages;
+}

package/src/get-cache-control.ts

@@ -0,0 +1,49 @@
+import { SharedV3Warning, SharedV3ProviderMetadata } from '@ai-sdk/provider';
+import { AlibabaCacheControl } from './alibaba-chat-prompt';
+
+// Alibaba allows a maximum of 4 cache breakpoints per request
+const MAX_CACHE_BREAKPOINTS = 4;
+
+function getCacheControl(
+  providerMetadata: SharedV3ProviderMetadata | undefined,
+): AlibabaCacheControl | undefined {
+  const alibaba = providerMetadata?.alibaba;
+
+  const cacheControlValue = alibaba?.cacheControl ?? alibaba?.cache_control;
+
+  // Pass through value assuming it is of the correct type.
+  // The Alibaba API will validate the value.
+  return cacheControlValue as AlibabaCacheControl | undefined;
+}
+
+export class CacheControlValidator {
+  private breakpointCount = 0;
+  private warnings: SharedV3Warning[] = [];
+
+  getCacheControl(
+    providerMetadata: SharedV3ProviderMetadata | undefined,
+  ): AlibabaCacheControl | undefined {
+    const cacheControlValue = getCacheControl(providerMetadata);
+
+    if (!cacheControlValue) {
+      return undefined;
+    }
+
+    // Validate cache breakpoint limit
+    this.breakpointCount++;
+    if (this.breakpointCount > MAX_CACHE_BREAKPOINTS) {
+      this.warnings.push({
+        type: 'unsupported',
+        feature: 'cacheControl breakpoint limit',
+        details: `Maximum ${MAX_CACHE_BREAKPOINTS} cache breakpoints exceeded (found ${this.breakpointCount}). This breakpoint will be ignored.`,
+      });
+      return undefined;
+    }
+
+    return cacheControlValue;
+  }
+
+  getWarnings(): SharedV3Warning[] {
+    return this.warnings;
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export { createAlibaba, alibaba } from './alibaba-provider';
+export type {
+  AlibabaProvider,
+  AlibabaProviderSettings,
+} from './alibaba-provider';
+export type {
+  AlibabaChatModelId,
+  AlibabaProviderOptions,
+} from './alibaba-chat-options';
+export type { AlibabaCacheControl } from './alibaba-chat-prompt';
+export type { AlibabaUsage } from './convert-alibaba-usage';
+export { VERSION } from './version';

package/src/version.ts

@@ -0,0 +1,3 @@
+declare const __PACKAGE_VERSION__: string;
+
+export const VERSION = __PACKAGE_VERSION__;