@ai-sdk/alibaba 2.0.0-beta.6 → 2.0.0-beta.61

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

@@ -3,34 +3,39 @@ import {
   mapOpenAICompatibleFinishReason,
   prepareTools,
 } from '@ai-sdk/openai-compatible/internal';
-import {
-  InvalidResponseDataError,
-  type LanguageModelV4,
-  type LanguageModelV4CallOptions,
-  type LanguageModelV4Content,
-  type LanguageModelV4FinishReason,
-  type LanguageModelV4GenerateResult,
-  type LanguageModelV4StreamPart,
-  type LanguageModelV4StreamResult,
-  type SharedV4Warning,
+import type {
+  LanguageModelV4,
+  LanguageModelV4CallOptions,
+  LanguageModelV4Content,
+  LanguageModelV4FinishReason,
+  LanguageModelV4GenerateResult,
+  LanguageModelV4StreamPart,
+  LanguageModelV4StreamResult,
+  SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
   generateId,
-  isParsableJson,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
   parseProviderOptions,
   postJsonToApi,
+  serializeModelOptions,
+  StreamingToolCallTracker,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type InferSchema,
   type ParseResult,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import {
-  alibabaLanguageModelOptions,
+  alibabaLanguageModelChatOptions,
   type AlibabaChatModelId,
-} from './alibaba-chat-options';
+} from './alibaba-chat-language-model-options';
 import type { AlibabaConfig } from './alibaba-config';
-import { alibabaFailedResponseHandler } from './alibaba-provider';
+import { alibabaFailedResponseHandler } from './alibaba-error';
 import { convertAlibabaUsage } from './convert-alibaba-usage';
 import { convertToAlibabaChatMessages } from './convert-to-alibaba-chat-messages';
 import { CacheControlValidator } from './get-cache-control';
@@ -44,12 +49,26 @@ import { CacheControlValidator } from './get-cache-control';
  * - Thinking budget control (thinking_budget)
  * - Prompt caching (cached_tokens tracking)
  */
-export class AlibabaLanguageModel implements LanguageModelV4 {
+export class AlibabaChatLanguageModel implements LanguageModelV4 {
   readonly specificationVersion = 'v4';
   readonly modelId: AlibabaChatModelId;
 
   private readonly config: AlibabaConfig;
 
+  static [WORKFLOW_SERIALIZE](model: AlibabaChatLanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: AlibabaChatModelId;
+    config: AlibabaConfig;
+  }) {
+    return new AlibabaChatLanguageModel(options.modelId, options.config);
+  }
+
   constructor(modelId: AlibabaChatModelId, config: AlibabaConfig) {
     this.modelId = modelId;
     this.config = config;
@@ -78,6 +97,7 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
     stopSequences,
     responseFormat,
     seed,
+    reasoning,
     providerOptions,
     tools,
     toolChoice,
@@ -89,7 +109,7 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
     const alibabaOptions = await parseProviderOptions({
       provider: 'alibaba',
       providerOptions,
-      schema: alibabaLanguageModelOptions,
+      schema: alibabaLanguageModelChatOptions,
     });
 
     // Warn about unsupported features
@@ -121,13 +141,11 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
             : { type: 'json_object' }
           : undefined,
 
-      // Alibaba-specific options
-      ...(alibabaOptions?.enableThinking != null
-        ? { enable_thinking: alibabaOptions.enableThinking }
-        : {}),
-      ...(alibabaOptions?.thinkingBudget != null
-        ? { thinking_budget: alibabaOptions.thinkingBudget }
-        : {}),
+      ...resolveAlibabaThinking({
+        reasoning,
+        alibabaOptions,
+        warnings,
+      }),
 
       // Convert messages with cache control support
       messages: convertToAlibabaChatMessages({
@@ -170,7 +188,7 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
       rawValue: rawResponse,
     } = await postJsonToApi({
       url: `${this.config.baseURL}/chat/completions`,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body: args,
       failedResponseHandler: alibabaFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
@@ -203,7 +221,7 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
       for (const toolCall of choice.message.tool_calls) {
         content.push({
           type: 'tool-call',
-          toolCallId: toolCall.id,
+          toolCallId: toolCall.id ?? generateId(),
           toolName: toolCall.function.name,
           input: toolCall.function.arguments!,
         });
@@ -241,7 +259,7 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
 
     const { responseHeaders, value: response } = await postJsonToApi({
       url: `${this.config.baseURL}/chat/completions`,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body,
       failedResponseHandler: alibabaFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
@@ -262,13 +280,7 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
     let activeText = false;
     let activeReasoningId: string | null = null;
 
-    // Track tool calls for accumulation across chunks
-    const toolCalls: Array<{
-      id: string;
-      type: 'function';
-      function: { name: string; arguments: string };
-      hasFinished: boolean;
-    }> = [];
+    let toolCallTracker: StreamingToolCallTracker;
 
     return {
       stream: response.pipeThrough(
@@ -277,6 +289,9 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
           LanguageModelV4StreamPart
         >({
           start(controller) {
+            toolCallTracker = new StreamingToolCallTracker(controller, {
+              generateId,
+            });
             controller.enqueue({ type: 'stream-start', warnings });
           },
 
@@ -381,106 +396,7 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
               }
 
               for (const toolCallDelta of delta.tool_calls) {
-                const index = toolCallDelta.index ?? toolCalls.length;
-
-                // New tool call - first chunk with id and name
-                if (toolCalls[index] == null) {
-                  if (toolCallDelta.id == null) {
-                    throw new InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'id' to be a string.`,
-                    });
-                  }
-
-                  if (toolCallDelta.function?.name == null) {
-                    throw new InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'function.name' to be a string.`,
-                    });
-                  }
-
-                  controller.enqueue({
-                    type: 'tool-input-start',
-                    id: toolCallDelta.id,
-                    toolName: toolCallDelta.function.name,
-                  });
-
-                  toolCalls[index] = {
-                    id: toolCallDelta.id,
-                    type: 'function',
-                    function: {
-                      name: toolCallDelta.function.name,
-                      arguments: toolCallDelta.function.arguments ?? '',
-                    },
-                    hasFinished: false,
-                  };
-
-                  const toolCall = toolCalls[index];
-
-                  // Send initial delta if arguments started
-                  if (toolCall.function.arguments.length > 0) {
-                    controller.enqueue({
-                      type: 'tool-input-delta',
-                      id: toolCall.id,
-                      delta: toolCall.function.arguments,
-                    });
-                  }
-
-                  // Check if already complete (some providers send full tool call at once)
-                  if (isParsableJson(toolCall.function.arguments)) {
-                    controller.enqueue({
-                      type: 'tool-input-end',
-                      id: toolCall.id,
-                    });
-
-                    controller.enqueue({
-                      type: 'tool-call',
-                      toolCallId: toolCall.id,
-                      toolName: toolCall.function.name,
-                      input: toolCall.function.arguments,
-                    });
-
-                    toolCall.hasFinished = true;
-                  }
-
-                  continue;
-                }
-
-                // Existing tool call - accumulate arguments
-                const toolCall = toolCalls[index];
-
-                if (toolCall.hasFinished) {
-                  continue;
-                }
-
-                // Append arguments if not null (skip arguments: null chunks)
-                if (toolCallDelta.function?.arguments != null) {
-                  toolCall.function.arguments +=
-                    toolCallDelta.function.arguments;
-
-                  controller.enqueue({
-                    type: 'tool-input-delta',
-                    id: toolCall.id,
-                    delta: toolCallDelta.function.arguments,
-                  });
-                }
-
-                // Check if tool call is now complete
-                if (isParsableJson(toolCall.function.arguments)) {
-                  controller.enqueue({
-                    type: 'tool-input-end',
-                    id: toolCall.id,
-                  });
-
-                  controller.enqueue({
-                    type: 'tool-call',
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.function.name,
-                    input: toolCall.function.arguments,
-                  });
-
-                  toolCall.hasFinished = true;
-                }
+                toolCallTracker.processDelta(toolCallDelta);
               }
             }
 
@@ -505,6 +421,8 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
               controller.enqueue({ type: 'text-end', id: '0' });
             }
 
+            toolCallTracker.flush();
+
             controller.enqueue({
               type: 'finish',
               finishReason,
@@ -519,6 +437,52 @@ export class AlibabaLanguageModel implements LanguageModelV4 {
   }
 }
 
+function resolveAlibabaThinking({
+  reasoning,
+  alibabaOptions,
+  warnings,
+}: {
+  reasoning: LanguageModelV4CallOptions['reasoning'];
+  alibabaOptions:
+    | InferSchema<typeof alibabaLanguageModelChatOptions>
+    | undefined;
+  warnings: SharedV4Warning[];
+}): { enable_thinking?: boolean; thinking_budget?: number } {
+  if (
+    alibabaOptions?.enableThinking != null ||
+    alibabaOptions?.thinkingBudget != null
+  ) {
+    return {
+      ...(alibabaOptions.enableThinking != null
+        ? { enable_thinking: alibabaOptions.enableThinking }
+        : {}),
+      ...(alibabaOptions.thinkingBudget != null
+        ? { thinking_budget: alibabaOptions.thinkingBudget }
+        : {}),
+    };
+  }
+
+  if (!isCustomReasoning(reasoning)) {
+    return {};
+  }
+
+  if (reasoning === 'none') {
+    return { enable_thinking: false };
+  }
+
+  const thinkingBudget = mapReasoningToProviderBudget({
+    reasoning,
+    maxOutputTokens: 16384,
+    maxReasoningBudget: 16384,
+    warnings,
+  });
+
+  return {
+    enable_thinking: true,
+    ...(thinkingBudget != null ? { thinking_budget: thinkingBudget } : {}),
+  };
+}
+
 /**
  * Reference for schemas below:
  * https://www.alibabacloud.com/help/en/model-studio/qwen-api-via-openai-chat-completions

package/src/alibaba-config.ts

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

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

@@ -0,0 +1,33 @@
+import { z } from 'zod/v4';
+
+export type AlibabaEmbeddingModelId =
+  | 'text-embedding-v4'
+  | 'text-embedding-v3'
+  | (string & {});
+
+export const alibabaEmbeddingModelOptions = z.object({
+  /**
+   * Differentiates query text from document text for asymmetric retrieval tasks.
+   * Defaults to `document`.
+   */
+  textType: z.enum(['query', 'document']).optional(),
+
+  /**
+   * The dimension of the output embedding vectors. Defaults to 1024.
+   *
+   * `text-embedding-v4` also supports 1536 and 2048 dimensions.
+   */
+  dimension: z.number().optional(),
+
+  /**
+   * The output vector type. Defaults to `dense`.
+   *
+   * Sparse-only output is not supported by the AI SDK embedding interface,
+   * which requires dense number arrays.
+   */
+  outputType: z.enum(['dense', 'sparse', 'dense&sparse']).optional(),
+});
+
+export type AlibabaEmbeddingModelOptions = z.infer<
+  typeof alibabaEmbeddingModelOptions
+>;

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