@agentor/dashscope 0.0.1 → 0.0.2

package/README.md

@@ -12,6 +12,10 @@
 - **Responses API** - `/responses` endpoint with built-in tools support
 - **Embedding** - Text vectorization via OpenAI-compatible `/embeddings` endpoint
 - **Reranking** - Document reranking via `/reranks` endpoint
+- **Image Generation** - Text-to-image via multimodal generation endpoint
+- **Video Generation** - Text-to-video and image-to-video with async polling
+- **Speech Synthesis** - Text-to-speech for CosyVoice and Qwen-TTS models
+- **Transcription** - Speech-to-text for short and long audio
 - **Built-in Tools** - Web search, code interpreter, web extractor, file search, image search, MCP integration
 - **Thinking Mode** - Enable reasoning/thinking with configurable budget
 - **Multi-region** - Beijing, Singapore, US, Germany regions
@@ -318,6 +322,113 @@ const { ranking } = await rerank({
 });
 ```
 
+## Image Generation
+
+```typescript
+import { generateImage } from "ai";
+
+const { images } = await generateImage({
+  model: dashscope.imageModel("qwen-image-plus"),
+  prompt: "A cute cat sitting on a windowsill with sunlight streaming in",
+  providerOptions: {
+    dashscope: {
+      size: "1024*1024",
+    },
+  },
+});
+
+// images[0].uint8Array — raw image data
+// images[0].base64 — base64 encoded image
+```
+
+## Video Generation
+
+```typescript
+import { experimental_generateVideo as generateVideo } from "ai";
+
+// Text-to-video
+const { videos } = await generateVideo({
+  model: dashscope.videoModel("wan2.6-t2v"),
+  prompt: "A golden retriever running through a field of sunflowers",
+  providerOptions: {
+    dashscope: {
+      size: "1280*720",
+      duration: 5,
+    },
+  },
+});
+```
+
+### Image-to-Video
+
+Use a model ID containing `-i2v` for image-to-video mode:
+
+```typescript
+const { videos } = await generateVideo({
+  model: dashscope.videoModel("wan2.6-i2v-turbo"),
+  prompt: "The cat stretches and walks away",
+  providerOptions: {
+    dashscope: {
+      resolution: "720P",
+    },
+  },
+  image: "data:image/png;base64,...", // or a URL string
+});
+```
+
+## Speech Synthesis (TTS)
+
+```typescript
+import { experimental_generateSpeech as generateSpeech } from "ai";
+import { writeFileSync } from "fs";
+
+const { audio } = await generateSpeech({
+  model: dashscope.speechModel("cosyvoice-v3-flash"),
+  text: "Hello, welcome to Agentor.",
+  providerOptions: {
+    dashscope: {
+      voice: "longanyang",
+      format: "wav",
+      sampleRate: 24000,
+    },
+  },
+});
+
+writeFileSync("output.wav", audio.uint8Array);
+```
+
+## Transcription (Speech-to-Text)
+
+### Short Audio (Sync)
+
+```typescript
+import { experimental_transcribe as transcribe } from "ai";
+
+const { text } = await transcribe({
+  model: dashscope.transcriptionModel("qwen3-asr-flash"),
+  audio: new URL("https://example.com/audio.mp3"),
+});
+
+console.log(text);
+```
+
+### Long Audio (Async)
+
+For async models, provide the audio URL via `providerOptions`:
+
+```typescript
+const { text, segments } = await transcribe({
+  model: dashscope.transcriptionModel("qwen3-asr-flash-filetrans"),
+  audio: new Uint8Array(0), // placeholder
+  providerOptions: {
+    dashscope: {
+      fileUrl: "https://example.com/long-audio.mp3",
+      enableWords: true,
+    },
+  },
+});
+```
+
 ## Provider Configuration
 
 ```typescript
@@ -332,6 +443,85 @@ const dashscope = createDashScope({
 });
 ```
 
+## Available Models
+
+> For the complete and up-to-date model list, see [Alibaba Cloud Model Studio](https://help.aliyun.com/zh/model-studio/models).
+
+### Language Models (Chat)
+
+| Model                 | Description                               |
+| --------------------- | ----------------------------------------- |
+| `qwen3.6-max-preview` | Flagship model with strongest reasoning   |
+| `qwen3.6-plus`        | Recommended, balanced capability and cost |
+| `qwen3.6-flash`       | Fastest, ultra-low cost                   |
+| `qwen3.5-plus`        | Enhanced reasoning model                  |
+| `qwen3.5-flash`       | Fast and efficient model                  |
+| `qwen3-coder-plus`    | Code-optimized model                      |
+| `qwen3-coder-flash`   | Fast code model                           |
+| `qwq-plus`            | Dedicated reasoning model                 |
+| `deepseek-v4-pro`     | DeepSeek V4 Pro                           |
+| `deepseek-v4-flash`   | DeepSeek V4 Flash                         |
+| `kimi-k2.6`           | Moonshot Kimi K2.6                        |
+| `glm-5.1`             | Zhipu GLM 5.1                             |
+
+### Embedding Models
+
+| Model                          | Dimensions              | Description                         |
+| ------------------------------ | ----------------------- | ----------------------------------- |
+| `text-embedding-v4`            | 64-2048 (default 1024)  | Text embedding for search/RAG       |
+| `text-embedding-v3`            | 512-1024 (default 1024) | Legacy text embedding               |
+| `qwen3-vl-embedding`           | 256-2560 (default 2560) | Multimodal (text + image) embedding |
+| `tongyi-embedding-vision-plus` | 64-1152 (default 1152)  | Cross-modal search embedding        |
+
+### Reranking Models
+
+| Model             | Description                             |
+| ----------------- | --------------------------------------- |
+| `qwen3-rerank`    | Text reranking, 100+ languages          |
+| `qwen3-vl-rerank` | Multimodal reranking (text/image/video) |
+| `gte-rerank-v2`   | Semantic text reranking                 |
+
+### Image Models
+
+| Model                | Description                                  |
+| -------------------- | -------------------------------------------- |
+| `wan2.7-image-pro`   | Latest Wan image generation, up to 4096x4096 |
+| `wan2.7-image`       | Wan image generation, up to 2048x2048        |
+| `qwen-image-2.0-pro` | Qwen image generation and editing            |
+| `qwen-image-max`     | High quality image generation                |
+| `qwen-image-plus`    | Enhanced image generation                    |
+| `z-image-turbo`      | Fast image generation                        |
+
+### Video Models
+
+| Model              | Mode | Description                           |
+| ------------------ | ---- | ------------------------------------- |
+| `wan2.7-t2v`       | T2V  | Recommended text-to-video with audio  |
+| `wan2.6-t2v`       | T2V  | Text-to-video with audio              |
+| `wan2.2-t2v-plus`  | T2V  | Text-to-video (silent)                |
+| `wan2.7-i2v`       | I2V  | Recommended image-to-video with audio |
+| `wan2.6-i2v`       | I2V  | Image-to-video with audio             |
+| `wan2.6-i2v-flash` | I2V  | Fast image-to-video                   |
+
+### Speech Models (TTS)
+
+| Model                      | Description                        |
+| -------------------------- | ---------------------------------- |
+| `cosyvoice-v3.5-plus`      | Latest flagship, best quality      |
+| `cosyvoice-v3.5-flash`     | Latest lightweight                 |
+| `cosyvoice-v3-plus`        | V3 enhanced                        |
+| `cosyvoice-v3-flash`       | V3 fast synthesis                  |
+| `qwen3-tts-flash-realtime` | Qwen TTS with 17 human-like voices |
+
+### Transcription Models (STT)
+
+| Model                       | Mode  | Description                    |
+| --------------------------- | ----- | ------------------------------ |
+| `qwen3-asr-flash`           | Sync  | Short audio (up to 5 min)      |
+| `qwen3-asr-flash-filetrans` | Async | Long audio (up to 12 hours)    |
+| `fun-asr`                   | Async | Speaker diarization, hot words |
+| `paraformer-v2`             | Async | Legacy async transcription     |
+
 ## License
 
 MIT © [Demo Macro](https://www.demomacro.com/)

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { OpenAICompatibleEmbeddingModel } from "@ai-sdk/openai-compatible";
 import * as _$_ai_sdk_provider_utils0 from "@ai-sdk/provider-utils";
 import { FetchFunction } from "@ai-sdk/provider-utils";
-import { EmbeddingModelV3, LanguageModelV3, RerankingModelV3, RerankingModelV3CallOptions, SharedV3Warning } from "@ai-sdk/provider";
+import { EmbeddingModelV3, Experimental_VideoModelV3, Experimental_VideoModelV3CallOptions, ImageModelV3, ImageModelV3CallOptions, LanguageModelV3, RerankingModelV3, RerankingModelV3CallOptions, SharedV3Warning, SpeechModelV3, SpeechModelV3CallOptions, TranscriptionModelV3, TranscriptionModelV3CallOptions } from "@ai-sdk/provider";
 
 //#region src/tools.d.ts
 declare const webSearchToolFactory: _$_ai_sdk_provider_utils0.ProviderToolFactoryWithOutputSchema<Record<string, never>, {
@@ -132,16 +132,12 @@ type DashScopeResponsesTools = typeof responsesTools;
 //#endregion
 //#region src/types.d.ts
 type DashScopeRegion = "beijing" | "singapore" | "us" | "germany";
-declare const DASHSCOPE_REGION_BASE_URLS: Record<DashScopeRegion, {
-  baseURL: string;
-  videoBaseURL: string;
-}>;
+declare const DASHSCOPE_REGION_URLS: Record<DashScopeRegion, string>;
 interface DashScopeProviderSettings {
   apiKey?: string;
   region?: DashScopeRegion;
   workspaceId?: string;
   baseURL?: string;
-  videoBaseURL?: string;
   headers?: Record<string, string>;
   fetch?: FetchFunction;
   includeUsage?: boolean;
@@ -184,6 +180,10 @@ interface DashScopeProvider {
   languageModel(modelId: string): LanguageModelV3;
   embeddingModel(modelId: string): EmbeddingModelV3;
   rerankingModel(modelId: string): RerankingModelV3;
+  imageModel(modelId: string): ImageModelV3;
+  videoModel(modelId: string): Experimental_VideoModelV3;
+  speechModel(modelId: string): SpeechModelV3;
+  transcriptionModel(modelId: string): TranscriptionModelV3;
   chatOptions: (options: DashScopeChatOptions) => {
     providerOptions: {
       dashscope: DashScopeChatOptions;
@@ -215,6 +215,37 @@ declare class DashScopeEmbeddingModel extends OpenAICompatibleEmbeddingModel {
   constructor(modelId: string, config: DashScopeConfig);
 }
 //#endregion
+//#region src/image.d.ts
+interface DashScopeImageOptions {
+  /** Output image size, e.g. "2048*2048", "1024*1024", "1K", "2K". */
+  size?: string;
+  /** Negative prompt describing what to avoid. */
+  negativePrompt?: string;
+  /** Enable prompt extension/rewriting. Default depends on model. */
+  promptExtend?: boolean;
+  /** Add watermark. Default false. */
+  watermark?: boolean;
+  /** Number of images to generate. Default 1. */
+  n?: number;
+}
+declare class DashScopeImageModel implements ImageModelV3 {
+  readonly specificationVersion: "v3";
+  readonly modelId: string;
+  private readonly config;
+  constructor(modelId: string, config: DashScopeConfig);
+  get provider(): string;
+  get maxImagesPerCall(): number | undefined;
+  doGenerate(options: ImageModelV3CallOptions): Promise<{
+    images: string[];
+    warnings: SharedV3Warning[];
+    response: {
+      timestamp: Date;
+      modelId: string;
+      headers: Record<string, string> | undefined;
+    };
+  }>;
+}
+//#endregion
 //#region src/rerank.d.ts
 interface DashScopeRerankOptions {
   /** English instruction to guide the reranking strategy. */
@@ -240,10 +271,134 @@ declare class DashScopeRerankingModel implements RerankingModelV3 {
   }>;
 }
 //#endregion
+//#region src/speech.d.ts
+interface DashScopeSpeechOptions {
+  /** Voice name. Model-specific, e.g. "longanyang" for CosyVoice, "Cherry" for Qwen-TTS. */
+  voice?: string;
+  /** Output audio format: "wav", "mp3", "pcm". Default depends on model. */
+  format?: string;
+  /** Sample rate. Default depends on model. */
+  sampleRate?: number;
+  /** Language type for Qwen-TTS: "Chinese" | "English" | "Japanese" | etc. */
+  languageType?: string;
+  /** Speaking speed. 0.5-2.0, default 1.0. */
+  speed?: number;
+  /** Volume. 0.5-2.0, default 1.0. */
+  volume?: number;
+  /** Pitch. -12 to 12, default 0. */
+  pitch?: number;
+}
+declare class DashScopeSpeechModel implements SpeechModelV3 {
+  readonly specificationVersion: "v3";
+  readonly modelId: string;
+  private readonly config;
+  constructor(modelId: string, config: DashScopeConfig);
+  get provider(): string;
+  doGenerate(options: SpeechModelV3CallOptions): Promise<{
+    audio: Uint8Array<ArrayBuffer>;
+    warnings: SharedV3Warning[];
+    request: {
+      body: Record<string, unknown>;
+    };
+    response: {
+      timestamp: Date;
+      modelId: string;
+      headers: Record<string, string> | undefined;
+    };
+  }>;
+}
+//#endregion
+//#region src/transcription.d.ts
+interface DashScopeTranscriptionOptions {
+  /**
+   * Publicly accessible audio file URL for async transcription.
+   * Required for async models (filetrans, fun-asr, paraformer) when using long audio.
+   */
+  fileUrl?: string;
+  /** Language hint(s), e.g. ["zh", "en"]. */
+  languageHints?: string[];
+  /** Enable inverse text normalization (convert spoken numbers/dates to written form). */
+  enableItn?: boolean;
+  /** Enable word-level timestamps. */
+  enableWords?: boolean;
+  /** Channel IDs to transcribe. Default [0]. */
+  channelId?: number[];
+  /** Polling interval in ms. Default 5000. (async mode only) */
+  pollIntervalMs?: number;
+  /** Polling timeout in ms. Default 600000. (async mode only) */
+  pollTimeoutMs?: number;
+}
+declare class DashScopeTranscriptionModel implements TranscriptionModelV3 {
+  readonly specificationVersion: "v3";
+  readonly modelId: string;
+  private readonly config;
+  constructor(modelId: string, config: DashScopeConfig);
+  get provider(): string;
+  doGenerate(options: TranscriptionModelV3CallOptions): Promise<{
+    text: string;
+    segments: {
+      text: string;
+      startSecond: number;
+      endSecond: number;
+    }[];
+    language: undefined;
+    durationInSeconds: undefined;
+    warnings: SharedV3Warning[];
+    response: {
+      timestamp: Date;
+      modelId: string;
+      headers: Record<string, string> | undefined;
+    };
+  }>;
+  private doSync;
+  private doAsync;
+}
+//#endregion
+//#region src/video.d.ts
+interface DashScopeVideoOptions {
+  /** Negative prompt. */
+  negativePrompt?: string;
+  /** Enable prompt extension. */
+  promptExtend?: boolean;
+  /** Add watermark. Default false. */
+  watermark?: boolean;
+  /** Resolution for I2V: "720P" | "1080P". For T2V: use size "WIDTH*HEIGHT". */
+  resolution?: string;
+  /** Size in "WIDTH*HEIGHT" format (T2V/R2V). */
+  size?: string;
+  /** Video duration in seconds. */
+  duration?: number;
+  /** Polling interval in ms. Default 5000. */
+  pollIntervalMs?: number;
+  /** Polling timeout in ms. Default 600000. */
+  pollTimeoutMs?: number;
+}
+declare class DashScopeVideoModel implements Experimental_VideoModelV3 {
+  readonly specificationVersion: "v3";
+  readonly modelId: string;
+  private readonly config;
+  constructor(modelId: string, config: DashScopeConfig);
+  get provider(): string;
+  get maxVideosPerCall(): number | undefined;
+  doGenerate(options: Experimental_VideoModelV3CallOptions): Promise<{
+    videos: {
+      type: "url";
+      url: string;
+      mediaType: string;
+    }[];
+    warnings: SharedV3Warning[];
+    response: {
+      timestamp: Date;
+      modelId: string;
+      headers: Record<string, string> | undefined;
+    };
+  }>;
+}
+//#endregion
 //#region src/provider.d.ts
 declare function createDashScope(options?: DashScopeProviderSettings): DashScopeProvider;
 //#endregion
 //#region src/index.d.ts
 declare const dashscope: DashScopeProvider;
 //#endregion
-export { DASHSCOPE_REGION_BASE_URLS, DashScopeChatOptions, DashScopeEmbeddingModel, DashScopeEmbeddingOptions, DashScopeProvider, DashScopeProviderSettings, DashScopeRegion, DashScopeRerankOptions, DashScopeRerankingModel, DashScopeResponsesNamespace, DashScopeResponsesOptions, DashScopeResponsesTools, createDashScope, dashscope, responsesTools };
+export { DASHSCOPE_REGION_URLS, DashScopeChatOptions, DashScopeEmbeddingModel, DashScopeEmbeddingOptions, DashScopeImageModel, DashScopeImageOptions, DashScopeProvider, DashScopeProviderSettings, DashScopeRegion, DashScopeRerankOptions, DashScopeRerankingModel, DashScopeResponsesNamespace, DashScopeResponsesOptions, DashScopeResponsesTools, DashScopeSpeechModel, DashScopeSpeechOptions, DashScopeTranscriptionModel, DashScopeTranscriptionOptions, DashScopeVideoModel, DashScopeVideoOptions, createDashScope, dashscope, responsesTools };

package/dist/index.mjs

@@ -1,13 +1,14 @@
 import { OpenAICompatibleEmbeddingModel } from "@ai-sdk/openai-compatible";
-import { combineHeaders, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createProviderToolFactoryWithOutputSchema, generateId, isParsableJson, lazySchema, parseProviderOptions, postJsonToApi, zodSchema } from "@ai-sdk/provider-utils";
+import { combineHeaders, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createProviderToolFactoryWithOutputSchema, delay, generateId, getFromApi, isParsableJson, lazySchema, parseProviderOptions, postJsonToApi, zodSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
+import { AISDKError } from "@ai-sdk/provider";
 import { convertOpenAICompatibleChatUsage, getResponseMetadata, mapOpenAICompatibleFinishReason, prepareTools } from "@ai-sdk/openai-compatible/internal";
 //#region src/embedding.ts
 var DashScopeEmbeddingModel = class extends OpenAICompatibleEmbeddingModel {
 	constructor(modelId, config) {
 		super(modelId, {
 			provider: config.provider,
-			url: () => `${config.baseURL}/embeddings`,
+			url: () => `${config.baseURL}/compatible-mode/v1/embeddings`,
 			headers: config.headers,
 			fetch: config.fetch
 		});
@@ -21,6 +22,14 @@ const failedResponseHandler = createJsonErrorResponseHandler({
 	}) })),
 	errorToMessage: (data) => data.error.message
 });
+const nativeFailedHandler = createJsonErrorResponseHandler({
+	errorSchema: zodSchema(z.object({
+		code: z.string().nullish(),
+		message: z.string(),
+		request_id: z.string().nullish()
+	})),
+	errorToMessage: (data) => data.message
+});
 function convertResponsesUsage(usage) {
 	if (!usage) return {
 		inputTokens: {
@@ -50,6 +59,90 @@ function convertResponsesUsage(usage) {
 		raw: usage
 	};
 }
+function uint8ArrayToBase64(data) {
+	let binary = "";
+	for (let i = 0; i < data.length; i++) binary += String.fromCharCode(data[i]);
+	return btoa(binary);
+}
+//#endregion
+//#region src/image.ts
+const imageOptionsSchema = z.object({
+	size: z.string().optional(),
+	negativePrompt: z.string().optional(),
+	promptExtend: z.boolean().optional(),
+	watermark: z.boolean().optional(),
+	n: z.number().optional()
+});
+const imageResponseSchema = zodSchema(z.object({
+	output: z.object({ choices: z.array(z.object({ message: z.object({ content: z.array(z.object({ image: z.string().optional() })) }) })).optional() }).nullish(),
+	usage: z.object({
+		image_count: z.number().optional(),
+		width: z.number().optional(),
+		height: z.number().optional()
+	}).nullish(),
+	request_id: z.string().nullish()
+}));
+var DashScopeImageModel = class {
+	specificationVersion = "v3";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get maxImagesPerCall() {
+		return 1;
+	}
+	async doGenerate(options) {
+		const warnings = [];
+		const dsOptions = await parseProviderOptions({
+			provider: "dashscope",
+			providerOptions: options.providerOptions,
+			schema: imageOptionsSchema
+		});
+		const body = {
+			model: this.modelId,
+			input: { messages: [{
+				role: "user",
+				content: [{ text: options.prompt }]
+			}] },
+			parameters: {
+				...dsOptions?.size != null && { size: dsOptions.size },
+				...dsOptions?.negativePrompt != null && { negative_prompt: dsOptions.negativePrompt },
+				...dsOptions?.promptExtend != null && { prompt_extend: dsOptions.promptExtend },
+				...dsOptions?.watermark != null && { watermark: dsOptions.watermark },
+				...dsOptions?.n != null && { n: dsOptions.n }
+			}
+		};
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: `${this.config.baseURL}/api/v1/services/aigc/multimodal-generation/generation`,
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body,
+			failedResponseHandler: nativeFailedHandler,
+			successfulResponseHandler: createJsonResponseHandler(imageResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const imageUrls = response.output?.choices?.flatMap((c) => c.message.content.filter((p) => p.image != null).map((p) => p.image)) ?? [];
+		const images = [];
+		for (const url of imageUrls) {
+			const buffer = await (await (this.config.fetch ?? fetch)(url, { headers: this.config.headers() })).arrayBuffer();
+			images.push(uint8ArrayToBase64(new Uint8Array(buffer)));
+		}
+		return {
+			images,
+			warnings,
+			response: {
+				timestamp: /* @__PURE__ */ new Date(),
+				modelId: this.modelId,
+				headers: responseHeaders
+			}
+		};
+	}
+};
 //#endregion
 //#region src/rerank.ts
 const rerankResponseSchema = zodSchema(z.object({
@@ -81,7 +174,7 @@ var DashScopeRerankingModel = class {
 			...options.topN != null && { top_n: options.topN }
 		};
 		const { responseHeaders, value: response } = await postJsonToApi({
-			url: `${this.config.baseURL.replace("/compatible-mode/", "/compatible-api/")}/reranks`,
+			url: `${this.config.baseURL}/compatible-api/v1/reranks`,
 			headers: combineHeaders(this.config.headers(), options.headers),
 			body,
 			failedResponseHandler,
@@ -104,6 +197,94 @@ var DashScopeRerankingModel = class {
 	}
 };
 //#endregion
+//#region src/speech.ts
+const speechOptionsSchema = z.object({
+	voice: z.string().optional(),
+	format: z.string().optional(),
+	sampleRate: z.number().optional(),
+	languageType: z.string().optional(),
+	speed: z.number().optional(),
+	volume: z.number().optional(),
+	pitch: z.number().optional()
+});
+const cosyvoiceResponseSchema = zodSchema(z.object({
+	output: z.object({ audio: z.object({ url: z.string().optional() }).nullish() }).nullish(),
+	request_id: z.string().nullish()
+}));
+var DashScopeSpeechModel = class {
+	specificationVersion = "v3";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async doGenerate(options) {
+		const warnings = [];
+		const dsOptions = await parseProviderOptions({
+			provider: "dashscope",
+			providerOptions: options.providerOptions,
+			schema: speechOptionsSchema
+		});
+		const voice = dsOptions?.voice ?? "longanyang";
+		const format = dsOptions?.format ?? "wav";
+		const sampleRate = dsOptions?.sampleRate ?? 24e3;
+		const isCosyVoice = this.modelId.startsWith("cosyvoice");
+		let url;
+		let body;
+		if (isCosyVoice) {
+			url = `${this.config.baseURL}/api/v1/services/audio/tts/SpeechSynthesizer`;
+			body = {
+				model: this.modelId,
+				input: {
+					text: options.text,
+					voice,
+					format,
+					sample_rate: sampleRate,
+					...dsOptions?.speed != null && { speech_rate: dsOptions.speed },
+					...dsOptions?.volume != null && { volume: dsOptions.volume },
+					...dsOptions?.pitch != null && { pitch_rate: dsOptions.pitch }
+				}
+			};
+		} else {
+			url = `${this.config.baseURL}/api/v1/services/aigc/multimodal-generation/generation`;
+			body = {
+				model: this.modelId,
+				input: {
+					text: options.text,
+					voice,
+					...dsOptions?.languageType != null && { language_type: dsOptions.languageType }
+				}
+			};
+		}
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url,
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body,
+			failedResponseHandler: nativeFailedHandler,
+			successfulResponseHandler: createJsonResponseHandler(cosyvoiceResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const audioUrl = response.output?.audio?.url;
+		if (!audioUrl) throw new Error("No audio URL returned from TTS API");
+		const audioBuffer = await (await (this.config.fetch ?? fetch)(audioUrl, { headers: this.config.headers() })).arrayBuffer();
+		return {
+			audio: new Uint8Array(audioBuffer),
+			warnings,
+			request: { body },
+			response: {
+				timestamp: /* @__PURE__ */ new Date(),
+				modelId: this.modelId,
+				headers: responseHeaders
+			}
+		};
+	}
+};
+//#endregion
 //#region src/tools.ts
 const webSearchToolFactory = createProviderToolFactoryWithOutputSchema({
 	id: "dashscope.web_search",
@@ -178,23 +359,339 @@ const responsesTools = {
 	mcp: (args) => mcpToolFactory(args)
 };
 //#endregion
+//#region src/transcription.ts
+const transcriptionOptionsSchema = z.object({
+	fileUrl: z.string().optional(),
+	languageHints: z.array(z.string()).optional(),
+	enableItn: z.boolean().optional(),
+	enableWords: z.boolean().optional(),
+	channelId: z.array(z.number()).optional(),
+	pollIntervalMs: z.number().positive().optional(),
+	pollTimeoutMs: z.number().positive().optional()
+});
+const syncResponseSchema = zodSchema(z.object({
+	output: z.object({ choices: z.array(z.object({ message: z.object({ content: z.array(z.object({ text: z.string().optional() })) }) })).optional() }).nullish(),
+	request_id: z.string().nullish()
+}));
+const createTaskSchema$1 = zodSchema(z.object({
+	output: z.object({
+		task_id: z.string(),
+		task_status: z.string()
+	}).nullish(),
+	request_id: z.string().nullish()
+}));
+const taskStatusSchema$1 = zodSchema(z.object({
+	output: z.object({
+		task_id: z.string(),
+		task_status: z.string(),
+		result: z.object({ transcription_url: z.string().nullish() }).nullish(),
+		results: z.array(z.object({
+			subtask_status: z.string().nullish(),
+			transcription_url: z.string().nullish()
+		})).nullish(),
+		code: z.string().nullish(),
+		message: z.string().nullish()
+	}).nullish(),
+	request_id: z.string().nullish()
+}));
+function isAsyncModel(modelId) {
+	return modelId.includes("filetrans") || modelId.startsWith("fun-asr") || modelId.startsWith("paraformer");
+}
+function buildAudioUrl(audio, mediaType) {
+	if (typeof audio === "string") {
+		if (audio.startsWith("http")) return audio;
+		return `data:${mediaType};base64,${audio}`;
+	}
+	return `data:${mediaType};base64,${uint8ArrayToBase64(audio)}`;
+}
+var DashScopeTranscriptionModel = class {
+	specificationVersion = "v3";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async doGenerate(options) {
+		const warnings = [];
+		const dsOptions = await parseProviderOptions({
+			provider: "dashscope",
+			providerOptions: options.providerOptions,
+			schema: transcriptionOptionsSchema
+		}) ?? null;
+		if (isAsyncModel(this.modelId) && dsOptions?.fileUrl) return this.doAsync(options, dsOptions, warnings);
+		return this.doSync(options, dsOptions, warnings);
+	}
+	async doSync(options, dsOptions, warnings) {
+		const audioUrl = buildAudioUrl(options.audio, options.mediaType);
+		const body = {
+			model: this.modelId,
+			input: { messages: [{
+				role: "user",
+				content: [{ audio: audioUrl }]
+			}] },
+			parameters: {
+				result_format: "message",
+				...dsOptions?.enableItn != null && { asr_options: { enable_itn: dsOptions.enableItn } }
+			}
+		};
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: `${this.config.baseURL}/api/v1/services/aigc/multimodal-generation/generation`,
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body,
+			failedResponseHandler: nativeFailedHandler,
+			successfulResponseHandler: createJsonResponseHandler(syncResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			text: response.output?.choices?.[0]?.message.content.filter((p) => p.text != null).map((p) => p.text).join("") ?? "",
+			segments: [],
+			language: void 0,
+			durationInSeconds: void 0,
+			warnings,
+			request: { body },
+			response: {
+				timestamp: /* @__PURE__ */ new Date(),
+				modelId: this.modelId,
+				headers: responseHeaders
+			}
+		};
+	}
+	async doAsync(options, dsOptions, warnings) {
+		const audioUrl = dsOptions?.fileUrl;
+		if (!audioUrl) throw new AISDKError({
+			name: "DASHSCOPE_TRANSCRIPTION_ERROR",
+			message: "Async transcription requires providerOptions.dashscope.fileUrl with a publicly accessible audio URL."
+		});
+		const parameters = {};
+		if (dsOptions?.channelId != null) parameters.channel_id = dsOptions.channelId;
+		if (dsOptions?.enableItn != null) parameters.enable_itn = dsOptions.enableItn;
+		if (dsOptions?.enableWords != null) parameters.enable_words = dsOptions.enableWords;
+		if (dsOptions?.languageHints?.length) parameters.language_hints = dsOptions.languageHints;
+		const { value: createResponse } = await postJsonToApi({
+			url: `${this.config.baseURL}/api/v1/services/audio/asr/transcription`,
+			headers: combineHeaders(this.config.headers(), options.headers, { "X-DashScope-Async": "enable" }),
+			body: {
+				model: this.modelId,
+				input: { file_url: audioUrl },
+				...Object.keys(parameters).length > 0 && { parameters }
+			},
+			successfulResponseHandler: createJsonResponseHandler(createTaskSchema$1),
+			failedResponseHandler: nativeFailedHandler,
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const taskId = createResponse.output?.task_id;
+		if (!taskId) throw new AISDKError({
+			name: "DASHSCOPE_TRANSCRIPTION_ERROR",
+			message: `No task_id returned. Response: ${JSON.stringify(createResponse)}`
+		});
+		const pollInterval = dsOptions?.pollIntervalMs ?? 5e3;
+		const pollTimeout = dsOptions?.pollTimeoutMs ?? 6e5;
+		const startTime = Date.now();
+		while (true) {
+			await delay(pollInterval, { abortSignal: options.abortSignal });
+			if (Date.now() - startTime > pollTimeout) throw new AISDKError({
+				name: "DASHSCOPE_TRANSCRIPTION_TIMEOUT",
+				message: `Transcription timed out after ${pollTimeout}ms`
+			});
+			const { value: status, responseHeaders } = await getFromApi({
+				url: `${this.config.baseURL}/api/v1/tasks/${taskId}`,
+				headers: combineHeaders(this.config.headers(), options.headers, { "X-DashScope-Async": "enable" }),
+				successfulResponseHandler: createJsonResponseHandler(taskStatusSchema$1),
+				failedResponseHandler: nativeFailedHandler,
+				abortSignal: options.abortSignal,
+				fetch: this.config.fetch
+			});
+			const taskStatus = status.output?.task_status;
+			if (taskStatus === "SUCCEEDED") {
+				let transcriptionUrl = status.output?.result?.transcription_url;
+				if (!transcriptionUrl) transcriptionUrl = ((status.output?.results)?.find((r) => r.subtask_status === "SUCCEEDED"))?.transcription_url;
+				if (!transcriptionUrl) throw new AISDKError({
+					name: "DASHSCOPE_TRANSCRIPTION_ERROR",
+					message: `No transcription URL in response. Task ID: ${taskId}`
+				});
+				const resultData = await (await (this.config.fetch ?? fetch)(transcriptionUrl)).json();
+				let text = "";
+				const segments = [];
+				if (resultData.transcripts) for (const transcript of resultData.transcripts) {
+					text += transcript.text;
+					if (transcript.sentences) {
+						for (const sentence of transcript.sentences) if (sentence.begin_time != null && sentence.end_time != null) segments.push({
+							text: sentence.text,
+							startSecond: sentence.begin_time / 1e3,
+							endSecond: sentence.end_time / 1e3
+						});
+					}
+				}
+				return {
+					text,
+					segments,
+					language: void 0,
+					durationInSeconds: void 0,
+					warnings,
+					response: {
+						timestamp: /* @__PURE__ */ new Date(),
+						modelId: this.modelId,
+						headers: responseHeaders
+					}
+				};
+			}
+			if (taskStatus === "FAILED" || taskStatus === "CANCELED") throw new AISDKError({
+				name: "DASHSCOPE_TRANSCRIPTION_FAILED",
+				message: `Transcription ${taskStatus.toLowerCase()}. ${status.output?.message ?? ""}`
+			});
+		}
+	}
+};
+//#endregion
 //#region src/types.ts
-const DASHSCOPE_REGION_BASE_URLS = {
-	beijing: {
-		baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
-		videoBaseURL: "https://dashscope.aliyuncs.com"
-	},
-	singapore: {
-		baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
-		videoBaseURL: "https://dashscope-intl.aliyuncs.com"
-	},
-	us: {
-		baseURL: "https://dashscope-us.aliyuncs.com/compatible-mode/v1",
-		videoBaseURL: "https://dashscope-us.aliyuncs.com"
-	},
-	germany: {
-		baseURL: "https://{workspaceId}.eu-central-1.maas.aliyuncs.com/compatible-mode/v1",
-		videoBaseURL: "https://{workspaceId}.eu-central-1.maas.aliyuncs.com"
+const DASHSCOPE_REGION_URLS = {
+	beijing: "https://dashscope.aliyuncs.com",
+	singapore: "https://dashscope-intl.aliyuncs.com",
+	us: "https://dashscope-us.aliyuncs.com",
+	germany: "https://{workspaceId}.eu-central-1.maas.aliyuncs.com"
+};
+//#endregion
+//#region src/video.ts
+const videoOptionsSchema = z.object({
+	negativePrompt: z.string().optional(),
+	promptExtend: z.boolean().optional(),
+	watermark: z.boolean().optional(),
+	resolution: z.string().optional(),
+	size: z.string().optional(),
+	duration: z.number().optional(),
+	pollIntervalMs: z.number().positive().optional(),
+	pollTimeoutMs: z.number().positive().optional()
+});
+const createTaskSchema = zodSchema(z.object({
+	output: z.object({
+		task_id: z.string(),
+		task_status: z.string()
+	}).nullish(),
+	request_id: z.string().nullish()
+}));
+const taskStatusSchema = zodSchema(z.object({
+	output: z.object({
+		task_id: z.string(),
+		task_status: z.string(),
+		video_url: z.string().nullish(),
+		submit_time: z.string().nullish(),
+		scheduled_time: z.string().nullish(),
+		end_time: z.string().nullish(),
+		code: z.string().nullish(),
+		message: z.string().nullish()
+	}).nullish(),
+	usage: z.object({
+		duration: z.number().nullish(),
+		output_video_duration: z.number().nullish(),
+		size: z.string().nullish()
+	}).nullish(),
+	request_id: z.string().nullish()
+}));
+function detectMode(modelId) {
+	return modelId.includes("-i2v") ? "i2v" : "t2v";
+}
+var DashScopeVideoModel = class {
+	specificationVersion = "v3";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get maxVideosPerCall() {
+		return 1;
+	}
+	async doGenerate(options) {
+		const warnings = [];
+		const mode = detectMode(this.modelId);
+		const dsOptions = await parseProviderOptions({
+			provider: "dashscope",
+			providerOptions: options.providerOptions,
+			schema: videoOptionsSchema
+		});
+		const input = {};
+		if (options.prompt != null) input.prompt = options.prompt;
+		if (dsOptions?.negativePrompt != null) input.negative_prompt = dsOptions.negativePrompt;
+		if (mode === "i2v" && options.image != null) if (options.image.type === "url") input.img_url = options.image.url;
+		else input.img_url = typeof options.image.data === "string" ? options.image.data : uint8ArrayToBase64(options.image.data);
+		const parameters = {};
+		if (dsOptions?.duration != null) parameters.duration = dsOptions.duration;
+		if (options.seed != null) parameters.seed = options.seed;
+		if (dsOptions?.promptExtend != null) parameters.prompt_extend = dsOptions.promptExtend;
+		if (dsOptions?.watermark != null) parameters.watermark = dsOptions.watermark;
+		if (mode === "i2v" && dsOptions?.resolution != null) parameters.resolution = dsOptions.resolution;
+		else if (options.resolution != null) parameters.size = options.resolution.replace("x", "*");
+		else if (dsOptions?.size != null) parameters.size = dsOptions.size;
+		const { value: createResponse } = await postJsonToApi({
+			url: `${this.config.baseURL}/api/v1/services/aigc/video-generation/video-synthesis`,
+			headers: combineHeaders(this.config.headers(), options.headers, { "X-DashScope-Async": "enable" }),
+			body: {
+				model: this.modelId,
+				input,
+				parameters
+			},
+			successfulResponseHandler: createJsonResponseHandler(createTaskSchema),
+			failedResponseHandler: nativeFailedHandler,
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const taskId = createResponse.output?.task_id;
+		if (!taskId) throw new AISDKError({
+			name: "DASHSCOPE_VIDEO_ERROR",
+			message: `No task_id returned. Response: ${JSON.stringify(createResponse)}`
+		});
+		const pollInterval = dsOptions?.pollIntervalMs ?? 5e3;
+		const pollTimeout = dsOptions?.pollTimeoutMs ?? 6e5;
+		const startTime = Date.now();
+		while (true) {
+			await delay(pollInterval, { abortSignal: options.abortSignal });
+			if (Date.now() - startTime > pollTimeout) throw new AISDKError({
+				name: "DASHSCOPE_VIDEO_TIMEOUT",
+				message: `Video generation timed out after ${pollTimeout}ms`
+			});
+			const { value: status, responseHeaders } = await getFromApi({
+				url: `${this.config.baseURL}/api/v1/tasks/${taskId}`,
+				headers: combineHeaders(this.config.headers(), options.headers),
+				successfulResponseHandler: createJsonResponseHandler(taskStatusSchema),
+				failedResponseHandler: nativeFailedHandler,
+				abortSignal: options.abortSignal,
+				fetch: this.config.fetch
+			});
+			const taskStatus = status.output?.task_status;
+			if (taskStatus === "SUCCEEDED") {
+				const videoUrl = status.output?.video_url;
+				if (!videoUrl) throw new AISDKError({
+					name: "DASHSCOPE_VIDEO_ERROR",
+					message: `No video URL in response. Task ID: ${taskId}`
+				});
+				return {
+					videos: [{
+						type: "url",
+						url: videoUrl,
+						mediaType: "video/mp4"
+					}],
+					warnings,
+					response: {
+						timestamp: /* @__PURE__ */ new Date(),
+						modelId: this.modelId,
+						headers: responseHeaders
+					}
+				};
+			}
+			if (taskStatus === "FAILED" || taskStatus === "CANCELED") throw new AISDKError({
+				name: "DASHSCOPE_VIDEO_FAILED",
+				message: `Video generation ${taskStatus.toLowerCase()}. ${status.output?.message ?? ""}`
+			});
+		}
 	}
 };
 //#endregion
@@ -397,14 +894,7 @@ var DashScopeChatLanguageModel = class {
 				...options.presencePenalty != null && { presence_penalty: options.presencePenalty },
 				...options.stopSequences?.length && { stop: options.stopSequences },
 				...options.seed != null && { seed: options.seed },
-				...options.responseFormat?.type === "json" && { response_format: options.responseFormat.schema != null ? {
-					type: "json_schema",
-					json_schema: {
-						schema: options.responseFormat.schema,
-						name: options.responseFormat.name ?? "response",
-						description: options.responseFormat.description
-					}
-				} : { type: "json_object" } },
+				...options.responseFormat?.type === "json" && { response_format: { type: "json_object" } },
 				...apiTools != null && {
 					tools: apiTools,
 					tool_choice: toolChoice
@@ -422,7 +912,7 @@ var DashScopeChatLanguageModel = class {
 	async doGenerate(options) {
 		const { args, warnings } = await this.getArgs(options);
 		const { responseHeaders, value: response } = await postJsonToApi({
-			url: `${this.config.baseURL}/chat/completions`,
+			url: `${this.config.baseURL}/compatible-mode/v1/chat/completions`,
 			headers: combineHeaders(this.config.headers(), options.headers),
 			body: args,
 			failedResponseHandler,
@@ -468,7 +958,7 @@ var DashScopeChatLanguageModel = class {
 			stream: true
 		};
 		const { responseHeaders, value: response } = await postJsonToApi({
-			url: `${this.config.baseURL}/chat/completions`,
+			url: `${this.config.baseURL}/compatible-mode/v1/chat/completions`,
 			headers: combineHeaders(this.config.headers(), options.headers),
 			body,
 			failedResponseHandler,
@@ -1067,7 +1557,7 @@ var DashScopeResponsesLanguageModel = class {
 	async doGenerate(options) {
 		const { args: body, warnings } = await this.getArgs(options);
 		const { responseHeaders, value: response } = await postJsonToApi({
-			url: `${this.config.baseURL}/responses`,
+			url: `${this.config.baseURL}/compatible-mode/v1/responses`,
 			headers: combineHeaders(this.config.headers(), options.headers),
 			body,
 			failedResponseHandler,
@@ -1103,7 +1593,7 @@ var DashScopeResponsesLanguageModel = class {
 	async doStream(options) {
 		const { args: body, warnings } = await this.getArgs(options);
 		const { responseHeaders, value: response } = await postJsonToApi({
-			url: `${this.config.baseURL}/responses`,
+			url: `${this.config.baseURL}/compatible-mode/v1/responses`,
 			headers: combineHeaders(this.config.headers(), options.headers),
 			body: {
 				...body,
@@ -1212,10 +1702,9 @@ var DashScopeResponsesLanguageModel = class {
 //#endregion
 //#region src/provider.ts
 function createDashScope(options = {}) {
-	const { region = "beijing", workspaceId, baseURL: explicitBaseURL, videoBaseURL: _explicitVideoBaseURL, includeUsage, ...rest } = options;
-	const regionUrls = DASHSCOPE_REGION_BASE_URLS[region];
-	const baseURL = (explicitBaseURL ?? regionUrls.baseURL).replace("{workspaceId}", workspaceId ?? "");
+	const { region = "beijing", workspaceId, baseURL: explicitBaseURL, includeUsage, ...rest } = options;
 	if (region === "germany" && !explicitBaseURL && !workspaceId) throw new Error("workspaceId is required when region is 'germany'. See https://help.aliyun.com/zh/model-studio/obtain-the-app-id-and-workspace-id");
+	const baseURL = (explicitBaseURL ?? DASHSCOPE_REGION_URLS[region]).replace("{workspaceId}", workspaceId ?? "");
 	const apiKey = rest.apiKey ?? process.env.DASHSCOPE_API_KEY;
 	const getHeaders = () => {
 		const headers = {};
@@ -1223,32 +1712,53 @@ function createDashScope(options = {}) {
 		if (rest.headers) Object.assign(headers, rest.headers);
 		return headers;
 	};
-	const chatConfig = {
+	const baseConfig = {
 		provider: "dashscope",
 		baseURL,
 		headers: getHeaders,
-		fetch: rest.fetch,
-		includeUsage
+		fetch: rest.fetch
 	};
-	const createChatModel = (modelId) => new DashScopeChatLanguageModel(modelId, chatConfig);
-	const createEmbeddingModel = (modelId) => new DashScopeEmbeddingModel(modelId, chatConfig);
+	const createChatModel = (modelId) => new DashScopeChatLanguageModel(modelId, {
+		...baseConfig,
+		includeUsage
+	});
+	const createEmbeddingModel = (modelId) => new DashScopeEmbeddingModel(modelId, {
+		...baseConfig,
+		includeUsage
+	});
 	const createRerankingModel = (modelId) => new DashScopeRerankingModel(modelId, {
-		provider: "dashscope.rerank",
-		baseURL,
-		headers: getHeaders,
-		fetch: rest.fetch
+		...baseConfig,
+		provider: "dashscope.rerank"
 	});
 	const createResponsesModel = (modelId) => new DashScopeResponsesLanguageModel(modelId, {
-		provider: "dashscope.responses",
-		baseURL,
-		headers: getHeaders,
-		fetch: rest.fetch
+		...baseConfig,
+		provider: "dashscope.responses"
 	});
 	const responses = Object.assign(createResponsesModel, { tools: responsesTools });
+	const createImageModel = (modelId) => new DashScopeImageModel(modelId, {
+		...baseConfig,
+		provider: "dashscope.image"
+	});
+	const createVideoModel = (modelId) => new DashScopeVideoModel(modelId, {
+		...baseConfig,
+		provider: "dashscope.video"
+	});
+	const createSpeechModel = (modelId) => new DashScopeSpeechModel(modelId, {
+		...baseConfig,
+		provider: "dashscope.speech"
+	});
+	const createTranscriptionModel = (modelId) => new DashScopeTranscriptionModel(modelId, {
+		...baseConfig,
+		provider: "dashscope.transcription"
+	});
 	return Object.assign(createChatModel, {
 		languageModel: createChatModel,
 		embeddingModel: createEmbeddingModel,
 		rerankingModel: createRerankingModel,
+		imageModel: createImageModel,
+		videoModel: createVideoModel,
+		speechModel: createSpeechModel,
+		transcriptionModel: createTranscriptionModel,
 		chatOptions: (chatOpts) => ({ providerOptions: { dashscope: chatOpts } }),
 		responsesOptions: (responsesOpts) => ({ providerOptions: { dashscope: responsesOpts } }),
 		responses
@@ -1258,4 +1768,4 @@ function createDashScope(options = {}) {
 //#region src/index.ts
 const dashscope = createDashScope();
 //#endregion
-export { DASHSCOPE_REGION_BASE_URLS, DashScopeEmbeddingModel, DashScopeRerankingModel, createDashScope, dashscope, responsesTools };
+export { DASHSCOPE_REGION_URLS, DashScopeEmbeddingModel, DashScopeImageModel, DashScopeRerankingModel, DashScopeSpeechModel, DashScopeTranscriptionModel, DashScopeVideoModel, createDashScope, dashscope, responsesTools };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentor/dashscope",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "AI SDK provider for Alibaba Cloud DashScope (Bailian) API",
   "keywords": [
     "ai",