@agentor/dashscope 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1232 @@
+import { z } from "zod/v4";
+import { combineHeaders, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createProviderToolFactoryWithOutputSchema, generateId, isParsableJson, lazySchema, parseProviderOptions, postJsonToApi, zodSchema } from "@ai-sdk/provider-utils";
+import { mapOpenAICompatibleFinishReason, prepareTools } from "@ai-sdk/openai-compatible/internal";
+//#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"
+	}
+};
+//#endregion
+//#region src/tools.ts
+const webSearchToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "dashscope.web_search",
+	inputSchema: lazySchema(() => zodSchema(z.object({}))),
+	outputSchema: lazySchema(() => zodSchema(z.object({
+		query: z.string().optional(),
+		sources: z.array(z.object({
+			type: z.literal("url"),
+			url: z.string()
+		})).optional()
+	})))
+});
+const codeInterpreterToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "dashscope.code_interpreter",
+	inputSchema: lazySchema(() => zodSchema(z.object({}))),
+	outputSchema: lazySchema(() => zodSchema(z.object({
+		code: z.string().optional(),
+		outputs: z.array(z.object({
+			type: z.literal("logs"),
+			logs: z.string().optional()
+		})).optional()
+	})))
+});
+const webExtractorToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "dashscope.web_extractor",
+	inputSchema: lazySchema(() => zodSchema(z.object({}))),
+	outputSchema: lazySchema(() => zodSchema(z.object({
+		urls: z.array(z.string()).optional(),
+		goal: z.string().optional(),
+		output: z.string().optional()
+	})))
+});
+const fileSearchToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "dashscope.file_search",
+	inputSchema: lazySchema(() => zodSchema(z.object({}))),
+	outputSchema: lazySchema(() => zodSchema(z.object({
+		queries: z.array(z.string()).optional(),
+		results: z.array(z.object({
+			fileId: z.string().optional(),
+			filename: z.string().optional(),
+			score: z.number().optional(),
+			text: z.string().optional()
+		})).optional()
+	})))
+});
+const webSearchImageToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "dashscope.web_search_image",
+	inputSchema: lazySchema(() => zodSchema(z.object({}))),
+	outputSchema: lazySchema(() => zodSchema(z.object({ queries: z.array(z.string()).optional() })))
+});
+const imageSearchToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "dashscope.image_search",
+	inputSchema: lazySchema(() => zodSchema(z.object({}))),
+	outputSchema: lazySchema(() => zodSchema(z.object({})))
+});
+const mcpToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "dashscope.mcp",
+	inputSchema: lazySchema(() => zodSchema(z.object({}))),
+	outputSchema: lazySchema(() => zodSchema(z.object({})))
+});
+/**
+* Built-in tools for the Responses API.
+* Access via `dashscope.responses.tools`.
+*/
+const responsesTools = {
+	webSearch: (args = {}) => webSearchToolFactory(args),
+	codeInterpreter: (args = {}) => codeInterpreterToolFactory(args),
+	webExtractor: (args = {}) => webExtractorToolFactory(args),
+	fileSearch: (args) => fileSearchToolFactory(args),
+	webSearchImage: (args = {}) => webSearchImageToolFactory(args),
+	imageSearch: (args = {}) => imageSearchToolFactory(args),
+	mcp: (args) => mcpToolFactory(args)
+};
+//#endregion
+//#region src/chat.ts
+const chatOptionsSchema = z.object({
+	enableThinking: z.boolean().optional(),
+	thinkingBudget: z.number().positive().optional(),
+	parallelToolCalls: z.boolean().optional(),
+	enableSearch: z.boolean().optional(),
+	searchStrategy: z.enum([
+		"enable",
+		"enable_with_history",
+		"agent_max"
+	]).optional(),
+	enableCodeInterpreter: z.boolean().optional()
+});
+const usageSchema = z.object({
+	prompt_tokens: z.number(),
+	completion_tokens: z.number(),
+	total_tokens: z.number(),
+	prompt_tokens_details: z.object({
+		cached_tokens: z.number().nullish(),
+		cache_creation_input_tokens: z.number().nullish()
+	}).nullish(),
+	completion_tokens_details: z.object({ reasoning_tokens: z.number().nullish() }).nullish()
+});
+const chatResponseSchema = z.object({
+	id: z.string().nullish(),
+	created: z.number().nullish(),
+	model: z.string().nullish(),
+	choices: z.array(z.object({
+		message: z.object({
+			role: z.literal("assistant").nullish(),
+			content: z.string().nullish(),
+			reasoning_content: z.string().nullish(),
+			tool_calls: z.array(z.object({
+				id: z.string(),
+				type: z.literal("function"),
+				function: z.object({
+					name: z.string(),
+					arguments: z.string()
+				})
+			})).nullish()
+		}),
+		finish_reason: z.string().nullish(),
+		index: z.number()
+	})),
+	usage: usageSchema.nullish()
+});
+const chatChunkSchema = z.object({
+	id: z.string().nullish(),
+	created: z.number().nullish(),
+	model: z.string().nullish(),
+	choices: z.array(z.object({
+		delta: z.object({
+			role: z.enum(["assistant"]).nullish(),
+			content: z.string().nullish(),
+			reasoning_content: z.string().nullish(),
+			tool_calls: z.array(z.object({
+				index: z.number().nullish(),
+				id: z.string().nullish(),
+				type: z.literal("function").nullish(),
+				function: z.object({
+					name: z.string().nullish(),
+					arguments: z.string().nullish()
+				}).nullish()
+			})).nullish()
+		}),
+		finish_reason: z.string().nullish(),
+		index: z.number()
+	})),
+	usage: usageSchema.nullish()
+});
+const failedResponseHandler$1 = createJsonErrorResponseHandler({
+	errorSchema: z.object({ error: z.object({
+		message: z.string(),
+		code: z.string().nullish(),
+		type: z.string().nullish()
+	}) }),
+	errorToMessage: (data) => data.error.message
+});
+function convertUsage$1(usage) {
+	if (!usage) return {
+		inputTokens: {
+			total: 0,
+			noCache: void 0,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: 0,
+			text: void 0,
+			reasoning: void 0
+		}
+	};
+	const cacheRead = usage.prompt_tokens_details?.cached_tokens ?? void 0;
+	const cacheWrite = usage.prompt_tokens_details?.cache_creation_input_tokens ?? void 0;
+	const noCache = cacheRead != null || cacheWrite != null ? (usage.prompt_tokens ?? 0) - (cacheRead ?? 0) - (cacheWrite ?? 0) : void 0;
+	return {
+		inputTokens: {
+			total: usage.prompt_tokens ?? 0,
+			noCache,
+			cacheRead,
+			cacheWrite
+		},
+		outputTokens: {
+			total: usage.completion_tokens ?? 0,
+			text: void 0,
+			reasoning: usage.completion_tokens_details?.reasoning_tokens ?? void 0
+		}
+	};
+}
+function convertMessages(prompt) {
+	const messages = [];
+	for (const { role, content } of prompt) switch (role) {
+		case "system":
+			messages.push({
+				role: "system",
+				content
+			});
+			break;
+		case "user": {
+			const parts = [];
+			for (const part of content) switch (part.type) {
+				case "text":
+					parts.push({
+						type: "text",
+						text: part.text
+					});
+					break;
+				case "file":
+					if (part.mediaType.startsWith("image/")) {
+						const url = part.data instanceof URL ? part.data.toString() : `data:${part.mediaType === "image/*" ? "image/jpeg" : part.mediaType};base64,${convertToBase64(part.data)}`;
+						parts.push({
+							type: "image_url",
+							image_url: { url }
+						});
+					}
+					break;
+			}
+			if (parts.length === 1 && parts[0].type === "text") messages.push({
+				role: "user",
+				content: parts[0].text
+			});
+			else messages.push({
+				role: "user",
+				content: parts
+			});
+			break;
+		}
+		case "assistant": {
+			let text = "";
+			const toolCalls = [];
+			for (const part of content) switch (part.type) {
+				case "text":
+				case "reasoning":
+					text += part.text;
+					break;
+				case "tool-call":
+					toolCalls.push({
+						id: part.toolCallId,
+						type: "function",
+						function: {
+							name: part.toolName,
+							arguments: JSON.stringify(part.input)
+						}
+					});
+					break;
+			}
+			messages.push({
+				role: "assistant",
+				content: text || null,
+				...toolCalls.length > 0 && { tool_calls: toolCalls }
+			});
+			break;
+		}
+		case "tool":
+			for (const part of content) {
+				if (part.type === "tool-approval-response") continue;
+				let outputValue;
+				switch (part.output.type) {
+					case "text":
+					case "error-text":
+						outputValue = part.output.value;
+						break;
+					case "execution-denied":
+						outputValue = part.output.reason ?? "Tool execution denied.";
+						break;
+					default: outputValue = JSON.stringify(part.output.value);
+				}
+				messages.push({
+					role: "tool",
+					tool_call_id: part.toolCallId,
+					content: outputValue
+				});
+			}
+			break;
+	}
+	return messages;
+}
+var DashScopeChatLanguageModel = class {
+	specificationVersion = "v3";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get supportedUrls() {
+		return { "image/*": [/^https?:\/\/.*$/] };
+	}
+	async getArgs(options) {
+		const warnings = [];
+		if (options.frequencyPenalty != null) warnings.push({
+			type: "unsupported",
+			feature: "frequencyPenalty"
+		});
+		const dsOptions = await parseProviderOptions({
+			provider: "dashscope",
+			providerOptions: options.providerOptions,
+			schema: chatOptionsSchema
+		});
+		const { tools: apiTools, toolChoice, toolWarnings } = prepareTools({
+			tools: options.tools,
+			toolChoice: options.toolChoice
+		});
+		warnings.push(...toolWarnings);
+		return {
+			args: {
+				model: this.modelId,
+				messages: convertMessages(options.prompt),
+				...options.maxOutputTokens != null && { max_tokens: options.maxOutputTokens },
+				...options.temperature != null && { temperature: options.temperature },
+				...options.topP != null && { top_p: options.topP },
+				...options.topK != null && { top_k: options.topK },
+				...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" } },
+				...apiTools != null && {
+					tools: apiTools,
+					tool_choice: toolChoice
+				},
+				...dsOptions?.parallelToolCalls != null && { parallel_tool_calls: dsOptions.parallelToolCalls },
+				...dsOptions?.enableThinking != null && { enable_thinking: dsOptions.enableThinking },
+				...dsOptions?.thinkingBudget != null && { thinking_budget: dsOptions.thinkingBudget },
+				...dsOptions?.enableSearch != null && { enable_search: dsOptions.enableSearch },
+				...dsOptions?.searchStrategy != null && { search_options: { search_strategy: dsOptions.searchStrategy } },
+				...dsOptions?.enableCodeInterpreter != null && { enable_code_interpreter: dsOptions.enableCodeInterpreter }
+			},
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		const { args, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: `${this.config.baseURL}/chat/completions`,
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body: args,
+			failedResponseHandler: failedResponseHandler$1,
+			successfulResponseHandler: createJsonResponseHandler(chatResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const choice = response.choices[0];
+		const content = [];
+		if (choice.message.content != null && choice.message.content.length > 0) content.push({
+			type: "text",
+			text: choice.message.content
+		});
+		if (choice.message.reasoning_content != null && choice.message.reasoning_content.length > 0) content.push({
+			type: "reasoning",
+			text: choice.message.reasoning_content
+		});
+		if (choice.message.tool_calls != null) for (const toolCall of choice.message.tool_calls) content.push({
+			type: "tool-call",
+			toolCallId: toolCall.id,
+			toolName: toolCall.function.name,
+			input: toolCall.function.arguments
+		});
+		return {
+			content,
+			finishReason: {
+				unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+				raw: choice.finish_reason ?? void 0
+			},
+			usage: convertUsage$1(response.usage),
+			request: { body: JSON.stringify(args) },
+			response: {
+				id: response.id ?? void 0,
+				modelId: response.model ?? void 0,
+				timestamp: response.created ? /* @__PURE__ */ new Date(response.created * 1e3) : void 0,
+				headers: responseHeaders
+			},
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = await this.getArgs(options);
+		const body = {
+			...args,
+			stream: true
+		};
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: `${this.config.baseURL}/chat/completions`,
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body,
+			failedResponseHandler: failedResponseHandler$1,
+			successfulResponseHandler: createEventSourceResponseHandler(chatChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		let usage;
+		let isFirstChunk = true;
+		let activeText = false;
+		let activeReasoningId = null;
+		const toolCalls = [];
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const value = chunk.value;
+					if (isFirstChunk) {
+						isFirstChunk = false;
+						controller.enqueue({
+							type: "response-metadata",
+							id: value.id ?? void 0,
+							modelId: value.model ?? void 0,
+							timestamp: value.created ? /* @__PURE__ */ new Date(value.created * 1e3) : void 0
+						});
+					}
+					if (value.usage != null) usage = value.usage;
+					if (value.choices.length === 0) return;
+					const choice = value.choices[0];
+					const delta = choice.delta;
+					if (delta.reasoning_content != null && delta.reasoning_content.length > 0) {
+						if (activeReasoningId == null) {
+							if (activeText) {
+								controller.enqueue({
+									type: "text-end",
+									id: "0"
+								});
+								activeText = false;
+							}
+							activeReasoningId = generateId();
+							controller.enqueue({
+								type: "reasoning-start",
+								id: activeReasoningId
+							});
+						}
+						controller.enqueue({
+							type: "reasoning-delta",
+							id: activeReasoningId,
+							delta: delta.reasoning_content
+						});
+					}
+					if (delta.content != null && delta.content.length > 0) {
+						if (activeReasoningId != null) {
+							controller.enqueue({
+								type: "reasoning-end",
+								id: activeReasoningId
+							});
+							activeReasoningId = null;
+						}
+						if (!activeText) {
+							controller.enqueue({
+								type: "text-start",
+								id: "0"
+							});
+							activeText = true;
+						}
+						controller.enqueue({
+							type: "text-delta",
+							id: "0",
+							delta: delta.content
+						});
+					}
+					if (delta.tool_calls != null) {
+						if (activeReasoningId != null) {
+							controller.enqueue({
+								type: "reasoning-end",
+								id: activeReasoningId
+							});
+							activeReasoningId = null;
+						}
+						if (activeText) {
+							controller.enqueue({
+								type: "text-end",
+								id: "0"
+							});
+							activeText = false;
+						}
+						for (const toolCallDelta of delta.tool_calls) {
+							const index = toolCallDelta.index ?? toolCalls.length;
+							if (toolCalls[index] == null) {
+								if (toolCallDelta.id == null || toolCallDelta.function?.name == null) continue;
+								controller.enqueue({
+									type: "tool-input-start",
+									id: toolCallDelta.id,
+									toolName: toolCallDelta.function.name
+								});
+								toolCalls[index] = {
+									id: toolCallDelta.id,
+									function: {
+										name: toolCallDelta.function.name,
+										arguments: toolCallDelta.function.arguments ?? ""
+									},
+									hasFinished: false
+								};
+								const tc = toolCalls[index];
+								if (tc.function.arguments.length > 0) controller.enqueue({
+									type: "tool-input-delta",
+									id: tc.id,
+									delta: tc.function.arguments
+								});
+								if (isParsableJson(tc.function.arguments)) {
+									controller.enqueue({
+										type: "tool-input-end",
+										id: tc.id
+									});
+									controller.enqueue({
+										type: "tool-call",
+										toolCallId: tc.id,
+										toolName: tc.function.name,
+										input: tc.function.arguments
+									});
+									tc.hasFinished = true;
+								}
+								continue;
+							}
+							const tc = toolCalls[index];
+							if (tc.hasFinished) continue;
+							if (toolCallDelta.function?.arguments != null) {
+								tc.function.arguments += toolCallDelta.function.arguments;
+								controller.enqueue({
+									type: "tool-input-delta",
+									id: tc.id,
+									delta: toolCallDelta.function.arguments
+								});
+							}
+							if (isParsableJson(tc.function.arguments)) {
+								controller.enqueue({
+									type: "tool-input-end",
+									id: tc.id
+								});
+								controller.enqueue({
+									type: "tool-call",
+									toolCallId: tc.id,
+									toolName: tc.function.name,
+									input: tc.function.arguments
+								});
+								tc.hasFinished = true;
+							}
+						}
+					}
+					if (choice.finish_reason != null) finishReason = {
+						unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+						raw: choice.finish_reason
+					};
+				},
+				flush(controller) {
+					if (activeReasoningId != null) controller.enqueue({
+						type: "reasoning-end",
+						id: activeReasoningId
+					});
+					if (activeText) controller.enqueue({
+						type: "text-end",
+						id: "0"
+					});
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage: convertUsage$1(usage)
+					});
+				}
+			})),
+			request: { body: JSON.stringify(body) },
+			response: { headers: responseHeaders }
+		};
+	}
+};
+//#endregion
+//#region src/responses.ts
+const responsesOptionsSchema = zodSchema(z.object({
+	enableThinking: z.boolean().optional(),
+	reasoning: z.object({ effort: z.enum([
+		"none",
+		"minimal",
+		"low",
+		"medium",
+		"high"
+	]) }).optional(),
+	previousResponseId: z.string().optional(),
+	conversation: z.string().optional(),
+	instructions: z.string().optional(),
+	includeUsage: z.boolean().optional()
+}));
+const errorSchema = zodSchema(z.object({ error: z.object({
+	message: z.string(),
+	type: z.string().optional(),
+	code: z.string().optional()
+}) }));
+const responseSchema = zodSchema(z.object({
+	id: z.string(),
+	created_at: z.number().optional(),
+	object: z.literal("response"),
+	model: z.string().optional(),
+	status: z.string().optional(),
+	output: z.array(z.record(z.string(), z.unknown())).optional(),
+	usage: z.object({
+		input_tokens: z.number(),
+		output_tokens: z.number(),
+		total_tokens: z.number(),
+		input_tokens_details: z.object({ cached_tokens: z.number() }).optional(),
+		output_tokens_details: z.object({ reasoning_tokens: z.number() }).optional()
+	}).optional(),
+	error: z.object({ message: z.string() }).nullable().optional()
+}).loose());
+const streamChunkSchema = zodSchema(z.object({ type: z.string() }).loose());
+const failedResponseHandler = createJsonErrorResponseHandler({
+	errorSchema,
+	errorToMessage: (data) => data.error.message
+});
+function convertUsage(usage) {
+	if (!usage) return {
+		inputTokens: {
+			total: 0,
+			noCache: void 0,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: 0,
+			text: void 0,
+			reasoning: void 0
+		}
+	};
+	const details = usage.output_tokens_details;
+	const inputDetails = usage.input_tokens_details;
+	return {
+		inputTokens: {
+			total: usage.input_tokens ?? 0,
+			noCache: void 0,
+			cacheRead: inputDetails?.cached_tokens ?? void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: usage.output_tokens ?? 0,
+			text: void 0,
+			reasoning: details?.reasoning_tokens ?? void 0
+		},
+		raw: usage
+	};
+}
+function mapFinishReason(status) {
+	switch (status) {
+		case "completed": return {
+			unified: "stop",
+			raw: status
+		};
+		case "incomplete": return {
+			unified: "length",
+			raw: status
+		};
+		case "failed":
+		case "cancelled": return {
+			unified: "error",
+			raw: status
+		};
+		default: return {
+			unified: "other",
+			raw: status
+		};
+	}
+}
+function mapToolChoice(toolChoice) {
+	switch (toolChoice.type) {
+		case "auto": return "auto";
+		case "none": return "none";
+		case "required": return "required";
+		case "tool": return {
+			type: "allowed_tools",
+			mode: "auto",
+			tools: [{
+				type: "function",
+				name: toolChoice.toolName
+			}]
+		};
+	}
+}
+function convertOutput(output) {
+	const content = [];
+	for (const item of output) switch (item.type) {
+		case "message": {
+			const parts = item.content;
+			if (parts) {
+				for (const part of parts) if (part.type === "output_text" && typeof part.text === "string") content.push({
+					type: "text",
+					text: part.text
+				});
+			}
+			break;
+		}
+		case "reasoning": {
+			const summary = item.summary;
+			if (summary) {
+				for (const s of summary) if (s.text) content.push({
+					type: "reasoning",
+					text: s.text
+				});
+			}
+			break;
+		}
+		case "function_call":
+			content.push({
+				type: "tool-call",
+				toolCallId: item.call_id ?? "",
+				toolName: item.name ?? "",
+				input: item.arguments,
+				providerExecuted: false
+			});
+			break;
+		case "web_search_call": {
+			const action = item.action;
+			const sources = action?.sources;
+			if (sources) {
+				for (const source of sources) if (source.url) content.push({
+					type: "source",
+					sourceType: "url",
+					id: item.id ?? "",
+					url: source.url,
+					title: source.title
+				});
+			}
+			content.push({
+				type: "tool-call",
+				toolCallId: item.id ?? "",
+				toolName: "web_search",
+				input: JSON.stringify({
+					query: action?.query,
+					sources
+				}),
+				providerExecuted: true
+			});
+			break;
+		}
+		case "code_interpreter_call":
+			content.push({
+				type: "tool-call",
+				toolCallId: item.id ?? "",
+				toolName: "code_interpreter",
+				input: JSON.stringify({
+					code: item.code,
+					outputs: item.outputs,
+					containerId: item.container_id
+				}),
+				providerExecuted: true
+			});
+			break;
+		case "web_extractor_call":
+			content.push({
+				type: "tool-call",
+				toolCallId: item.id ?? "",
+				toolName: "web_extractor",
+				input: JSON.stringify({
+					urls: item.urls,
+					goal: item.goal
+				}),
+				providerExecuted: true
+			});
+			if (item.output) content.push({
+				type: "tool-result",
+				toolCallId: item.id ?? "",
+				toolName: "web_extractor",
+				result: item.output
+			});
+			break;
+		case "file_search_call":
+			content.push({
+				type: "tool-call",
+				toolCallId: item.id ?? "",
+				toolName: "file_search",
+				input: JSON.stringify({
+					queries: item.queries,
+					results: item.results
+				}),
+				providerExecuted: true
+			});
+			break;
+		case "web_search_image_call":
+			content.push({
+				type: "tool-call",
+				toolCallId: item.id ?? "",
+				toolName: "web_search_image",
+				input: JSON.stringify({
+					name: item.name,
+					arguments: item.arguments
+				}),
+				providerExecuted: true
+			});
+			if (item.output) content.push({
+				type: "tool-result",
+				toolCallId: item.id ?? "",
+				toolName: "web_search_image",
+				result: item.output
+			});
+			break;
+		case "image_search_call":
+			content.push({
+				type: "tool-call",
+				toolCallId: item.id ?? "",
+				toolName: "image_search",
+				input: JSON.stringify({
+					name: item.name,
+					arguments: item.arguments
+				}),
+				providerExecuted: true
+			});
+			if (item.output) content.push({
+				type: "tool-result",
+				toolCallId: item.id ?? "",
+				toolName: "image_search",
+				result: item.output
+			});
+			break;
+		case "mcp_call": {
+			const toolName = item.name ?? item.server_label ?? "mcp";
+			content.push({
+				type: "tool-call",
+				toolCallId: item.id ?? "",
+				toolName,
+				input: item.arguments ?? "{}",
+				providerExecuted: true
+			});
+			if (item.output) content.push({
+				type: "tool-result",
+				toolCallId: item.id ?? "",
+				toolName,
+				result: item.output
+			});
+			break;
+		}
+	}
+	return content;
+}
+function prepareTools$1(tools) {
+	if (!tools?.length) return [];
+	const apiTools = [];
+	for (const tool of tools) if (tool.type === "provider") switch (tool.id) {
+		case "dashscope.web_search":
+			apiTools.push({ type: "web_search" });
+			break;
+		case "dashscope.code_interpreter":
+			apiTools.push({ type: "code_interpreter" });
+			break;
+		case "dashscope.web_extractor":
+			apiTools.push({ type: "web_extractor" });
+			break;
+		case "dashscope.file_search": {
+			const args = tool.args;
+			apiTools.push({
+				type: "file_search",
+				vector_store_ids: args.vectorStoreIds
+			});
+			break;
+		}
+		case "dashscope.web_search_image":
+			apiTools.push({ type: "web_search_image" });
+			break;
+		case "dashscope.image_search":
+			apiTools.push({ type: "image_search" });
+			break;
+		case "dashscope.mcp": {
+			const args = tool.args;
+			apiTools.push({
+				type: "mcp",
+				server_protocol: args.serverProtocol,
+				server_label: args.serverLabel,
+				server_url: args.serverUrl,
+				...args.serverDescription && { server_description: args.serverDescription },
+				...args.headers && { headers: args.headers }
+			});
+			break;
+		}
+	}
+	else apiTools.push({
+		type: "function",
+		name: tool.name,
+		...tool.description && { description: tool.description },
+		parameters: tool.inputSchema
+	});
+	return apiTools;
+}
+function convertFilePart(part) {
+	const data = part.data;
+	if (data instanceof URL) return {
+		type: "input_image",
+		image_url: data.toString()
+	};
+	if (typeof data === "string") {
+		if (data.startsWith("data:")) return {
+			type: "input_image",
+			image_url: data
+		};
+		return {
+			type: "input_image",
+			image_url: `data:${part.mediaType};base64,${data}`
+		};
+	}
+}
+function convertToolResultOutput(output) {
+	if (typeof output === "string") return output;
+	if (output && typeof output === "object" && "type" in output && output.type === "text") return output.value;
+	return JSON.stringify(output);
+}
+function convertInput(prompt) {
+	const input = [];
+	for (const message of prompt) {
+		const { role, content } = message;
+		if (typeof content === "string") {
+			input.push({
+				role,
+				content
+			});
+			continue;
+		}
+		const textParts = [];
+		const fileParts = [];
+		const functionCalls = [];
+		const functionOutputs = [];
+		for (const part of content) switch (part.type) {
+			case "text":
+				textParts.push(part.text);
+				break;
+			case "file": {
+				const filePart = convertFilePart(part);
+				if (filePart) fileParts.push(filePart);
+				break;
+			}
+			case "reasoning": break;
+			case "tool-call": {
+				const callPart = part;
+				functionCalls.push({
+					type: "function_call",
+					name: callPart.toolName,
+					arguments: typeof callPart.input === "string" ? callPart.input : JSON.stringify(callPart.input),
+					call_id: callPart.toolCallId
+				});
+				break;
+			}
+			case "tool-result": {
+				const resultPart = part;
+				functionOutputs.push({
+					type: "function_call_output",
+					call_id: resultPart.toolCallId,
+					output: convertToolResultOutput(resultPart.output)
+				});
+				break;
+			}
+		}
+		const messageParts = [...textParts.map((t) => ({
+			type: "text",
+			text: t
+		})), ...fileParts];
+		if (messageParts.length > 0) if (messageParts.length === 1 && textParts.length === 1) input.push({
+			role,
+			content: textParts[0]
+		});
+		else input.push({
+			role,
+			content: messageParts
+		});
+		input.push(...functionCalls, ...functionOutputs);
+	}
+	return input;
+}
+var DashScopeResponsesLanguageModel = class {
+	specificationVersion = "v3";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get supportedUrls() {
+		return {};
+	}
+	async getArgs(options) {
+		const warnings = [];
+		if (options.topK != null) warnings.push({
+			type: "unsupported",
+			feature: "topK"
+		});
+		const dsOptions = await parseProviderOptions({
+			provider: "dashscope",
+			providerOptions: options.providerOptions,
+			schema: responsesOptionsSchema
+		});
+		const tools = prepareTools$1(options.tools);
+		const input = convertInput(options.prompt);
+		return {
+			args: {
+				model: this.modelId,
+				input,
+				...options.temperature != null && { temperature: options.temperature },
+				...options.topP != null && { top_p: options.topP },
+				...options.maxOutputTokens != null && { max_output_tokens: options.maxOutputTokens },
+				...options.stopSequences?.length && { stop: options.stopSequences },
+				...tools.length > 0 && { tools },
+				...options.toolChoice && { tool_choice: mapToolChoice(options.toolChoice) },
+				...dsOptions?.enableThinking != null && { enable_thinking: dsOptions.enableThinking },
+				...dsOptions?.reasoning != null && { reasoning: dsOptions.reasoning },
+				...dsOptions?.previousResponseId && { previous_response_id: dsOptions.previousResponseId },
+				...dsOptions?.conversation && { conversation: dsOptions.conversation },
+				...dsOptions?.instructions && { instructions: dsOptions.instructions }
+			},
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		const { args: body, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: `${this.config.baseURL}/responses`,
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body,
+			failedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(responseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		if (response.error) throw new Error(`DashScope Responses API error: ${response.error.message}`);
+		const content = convertOutput(response.output ?? []);
+		const hasToolCall = content.some((c) => c.type === "tool-call" && "providerExecuted" in c && !c.providerExecuted);
+		let finishReason = mapFinishReason(response.status);
+		if (hasToolCall && finishReason.unified === "stop") finishReason = {
+			unified: "tool-calls",
+			raw: response.status
+		};
+		return {
+			content,
+			finishReason,
+			usage: convertUsage(response.usage),
+			request: { body },
+			response: {
+				id: response.id ?? void 0,
+				headers: responseHeaders
+			},
+			warnings,
+			providerMetadata: response.id ? { dashscope: {
+				responseId: response.id,
+				...response.model && { model: response.model },
+				...response.created_at && { createdAt: response.created_at }
+			} } : void 0
+		};
+	}
+	async doStream(options) {
+		const { args: body, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: `${this.config.baseURL}/responses`,
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body: {
+				...body,
+				stream: true
+			},
+			failedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(streamChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		let finishReason;
+		let usage;
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					if (!chunk.success) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const val = chunk.value;
+					switch (val.type) {
+						case "response.output_text.delta":
+							controller.enqueue({
+								type: "text-delta",
+								id: String(val.output_index ?? 0),
+								delta: val.delta ?? ""
+							});
+							break;
+						case "response.reasoning_summary_text.delta":
+							controller.enqueue({
+								type: "reasoning-delta",
+								id: String(val.output_index ?? 0),
+								delta: val.delta ?? ""
+							});
+							break;
+						case "response.output_item.added": {
+							const item = val.item;
+							if (item?.type === "function_call") controller.enqueue({
+								type: "tool-input-start",
+								id: item.id ?? "",
+								toolName: item.name ?? ""
+							});
+							break;
+						}
+						case "response.mcp_call_arguments.delta":
+							controller.enqueue({
+								type: "tool-input-delta",
+								id: val.item_id ?? "",
+								delta: val.delta ?? ""
+							});
+							break;
+						case "response.completed": {
+							const resp = val.response;
+							finishReason = mapFinishReason(resp?.status);
+							if (resp?.usage) usage = convertUsage(resp.usage);
+							if (resp?.id) controller.enqueue({
+								type: "response-metadata",
+								id: resp.id,
+								modelId: resp.model,
+								timestamp: resp.created_at ? /* @__PURE__ */ new Date(resp.created_at * 1e3) : void 0
+							});
+							break;
+						}
+					}
+				},
+				flush(controller) {
+					if (finishReason || usage) controller.enqueue({
+						type: "finish",
+						usage: usage ?? {
+							inputTokens: {
+								total: 0,
+								noCache: void 0,
+								cacheRead: void 0,
+								cacheWrite: void 0
+							},
+							outputTokens: {
+								total: 0,
+								text: void 0,
+								reasoning: void 0
+							}
+						},
+						finishReason: finishReason ?? {
+							unified: "stop",
+							raw: void 0
+						}
+					});
+				}
+			})),
+			response: { headers: responseHeaders }
+		};
+	}
+};
+//#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 ?? "");
+	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 apiKey = rest.apiKey ?? process.env.DASHSCOPE_API_KEY;
+	const getHeaders = () => {
+		const headers = {};
+		if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+		if (rest.headers) Object.assign(headers, rest.headers);
+		return headers;
+	};
+	const chatConfig = {
+		provider: "dashscope",
+		baseURL,
+		headers: getHeaders,
+		fetch: rest.fetch,
+		includeUsage
+	};
+	const createChatModel = (modelId) => new DashScopeChatLanguageModel(modelId, chatConfig);
+	const createResponsesModel = (modelId) => new DashScopeResponsesLanguageModel(modelId, {
+		provider: "dashscope.responses",
+		baseURL,
+		headers: getHeaders,
+		fetch: rest.fetch
+	});
+	const responses = Object.assign(createResponsesModel, { tools: responsesTools });
+	return Object.assign(createChatModel, {
+		languageModel: createChatModel,
+		chatOptions: (chatOpts) => ({ providerOptions: { dashscope: chatOpts } }),
+		responsesOptions: (responsesOpts) => ({ providerOptions: { dashscope: responsesOpts } }),
+		responses
+	});
+}
+//#endregion
+//#region src/index.ts
+const dashscope = createDashScope();
+//#endregion
+export { DASHSCOPE_REGION_BASE_URLS, createDashScope, dashscope, responsesTools };