bailian-cli-core 1.1.3 → 1.2.0

package/dist/index.mjs

@@ -4,6 +4,9 @@ import { homedir } from "os";
 import { basename, join } from "path";
 import { stringify } from "yaml";
 import { createHash, createHmac, randomUUID } from "crypto";
+import { cpSync, existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync, writeFileSync as writeFileSync$1 } from "node:fs";
+import { dirname, join as join$1 } from "node:path";
+import { fileURLToPath } from "node:url";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -111,6 +114,20 @@ const VALID_REGIONS = new Set([
 	"intl"
 ]);
 const VALID_OUTPUTS = new Set(["text", "json"]);
+/**
+* A syntactically valid absolute http(s) URL. Used to validate `base_url` and
+* `console_gateway_url` from the config file: the credential-bearing client
+* sends the Bearer token to these origins, so a bare `startsWith("http")` check
+* (which also accepts e.g. "httpfoo://…") is too loose.
+*/
+function isHttpUrl(value) {
+	try {
+		const u = new URL(value);
+		return u.protocol === "http:" || u.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
 function parseConfigFile(raw) {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
 	const obj = raw;
@@ -119,7 +136,7 @@ function parseConfigFile(raw) {
 	if (typeof obj.access_token === "string" && obj.access_token.length > 0) out.access_token = obj.access_token;
 	else if (typeof obj.accessToken === "string" && obj.accessToken.length > 0) out.access_token = obj.accessToken;
 	if (typeof obj.region === "string" && VALID_REGIONS.has(obj.region)) out.region = obj.region;
-	if (typeof obj.base_url === "string" && obj.base_url.startsWith("http")) out.base_url = obj.base_url;
+	if (typeof obj.base_url === "string" && isHttpUrl(obj.base_url)) out.base_url = obj.base_url;
 	if (typeof obj.output === "string" && VALID_OUTPUTS.has(obj.output)) out.output = obj.output;
 	if (typeof obj.output_dir === "string" && obj.output_dir.length > 0) out.output_dir = obj.output_dir;
 	if (typeof obj.timeout === "number" && obj.timeout > 0) out.timeout = obj.timeout;
@@ -131,7 +148,7 @@ function parseConfigFile(raw) {
 	if (typeof obj.access_key_id === "string" && obj.access_key_id.length > 0) out.access_key_id = obj.access_key_id;
 	if (typeof obj.access_key_secret === "string" && obj.access_key_secret.length > 0) out.access_key_secret = obj.access_key_secret;
 	if (typeof obj.workspace_id === "string" && obj.workspace_id.length > 0) out.workspace_id = obj.workspace_id;
-	if (typeof obj.console_gateway_url === "string" && obj.console_gateway_url.startsWith("http")) out.console_gateway_url = obj.console_gateway_url;
+	if (typeof obj.console_gateway_url === "string" && isHttpUrl(obj.console_gateway_url)) out.console_gateway_url = obj.console_gateway_url;
 	if (typeof obj.telemetry === "boolean") out.telemetry = obj.telemetry;
 	return out;
 }
@@ -150,10 +167,14 @@ function getCredentialsPath() {
 }
 async function ensureConfigDir() {
 	const dir = getConfigDir();
-	await (await import("fs/promises")).mkdir(dir, {
+	const fs = await import("fs/promises");
+	await fs.mkdir(dir, {
 		recursive: true,
 		mode: 448
 	});
+	try {
+		await fs.chmod(dir, 448);
+	} catch {}
 }
 //#endregion
 //#region src/output/text.ts
@@ -240,7 +261,7 @@ function loadConfig(flags) {
 		accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID || file.access_key_id || void 0,
 		accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET || file.access_key_secret || void 0,
 		workspaceId: process.env.BAILIAN_WORKSPACE_ID || file.workspace_id || void 0,
-		consoleGatewayUrl: process.env.BAILIAN_CONSOLE_GATEWAY_URL || file.console_gateway_url || "https://bailian-cs.console.aliyun.com",
+		consoleGatewayUrl: process.env.BAILIAN_CONSOLE_GATEWAY_URL || file.console_gateway_url || "https://pre-bailian-cs.console.aliyun.com",
 		verbose: flags.verbose || process.env.DASHSCOPE_VERBOSE === "1",
 		quiet: flags.quiet || false,
 		noColor: flags.noColor || process.env.NO_COLOR !== void 0 || !process.stdout.isTTY,
@@ -401,10 +422,10 @@ function videoGenerateEndpoint(baseUrl) {
 	return `${baseUrl}/api/v1/services/aigc/video-generation/video-synthesis`;
 }
 function taskEndpoint(baseUrl, taskId) {
-	return `${baseUrl}/api/v1/tasks/${taskId}`;
+	return `${baseUrl}/api/v1/tasks/${encodeURIComponent(taskId)}`;
 }
 function appCompletionEndpoint(baseUrl, appId) {
-	return `${baseUrl}/api/v1/apps/${appId}/completion`;
+	return `${baseUrl}/api/v1/apps/${encodeURIComponent(appId)}/completion`;
 }
 function memoryAddEndpoint(baseUrl) {
 	return `${baseUrl}/api/v2/apps/memory/add`;
@@ -416,7 +437,7 @@ function memoryListEndpoint(baseUrl) {
 	return `${baseUrl}/api/v2/apps/memory/memory_nodes`;
 }
 function memoryNodeEndpoint(baseUrl, nodeId) {
-	return `${baseUrl}/api/v2/apps/memory/memory_nodes/${nodeId}`;
+	return `${baseUrl}/api/v2/apps/memory/memory_nodes/${encodeURIComponent(nodeId)}`;
 }
 function speechSynthesizeEndpoint(baseUrl) {
 	return `${baseUrl}/api/v1/services/audio/tts/SpeechSynthesizer`;
@@ -428,7 +449,7 @@ function profileSchemaEndpoint(baseUrl) {
 	return `${baseUrl}/api/v2/apps/memory/profile_schemas`;
 }
 function userProfileEndpoint(baseUrl, schemaId) {
-	return `${baseUrl}/api/v2/apps/memory/profile_schemas/${schemaId}/profiles`;
+	return `${baseUrl}/api/v2/apps/memory/profile_schemas/${encodeURIComponent(schemaId)}/profiles`;
 }
 function mcpWebSearchEndpoint(baseUrl) {
 	return `${baseUrl}/api/v1/mcps/WebSearch/mcp`;
@@ -456,6 +477,11 @@ function trackingHeaders() {
 	return { "x-dashscope-source-config": SOURCE_CONFIG };
 }
 //#endregion
+//#region src/utils/token.ts
+function maskToken(token) {
+	return token.length > 8 ? `${token.slice(0, 4)}...${token.slice(-4)}` : "***";
+}
+//#endregion
 //#region src/client/http.ts
 /**
 * Bailian requires `X-DashScope-OssResourceResolve: enable` on any request whose body
@@ -482,7 +508,7 @@ async function request(config, opts) {
 		headers["Authorization"] = `Bearer ${credential.token}`;
 		if (config.verbose) {
 			console.error(`> ${opts.method ?? "GET"} ${opts.url}`);
-			console.error(`> Auth: ${credential.token.slice(0, 8)}...`);
+			console.error(`> Auth: ${maskToken(credential.token)}`);
 			console.error(`> x-dashscope-source-config: ${SOURCE_CONFIG}`);
 		}
 	}
@@ -539,19 +565,25 @@ async function requestJson(config, opts) {
 }
 //#endregion
 //#region src/client/mcp.ts
+/**
+* Compose the streamable-HTTP MCP endpoint for a Bailian MCP server.
+* The path is `/api/v1/mcps/<serverCode>/mcp`; the `serverCode` is taken
+* verbatim from `bl mcp list` (e.g. `WebSearch`, `market-cmapi00073529`).
+*/
+function bailianMcpUrl(baseUrl, serverCode) {
+	return `${baseUrl.replace(/\/$/, "")}/api/v1/mcps/${serverCode}/mcp`;
+}
 var McpClient = class {
-	baseUrl;
+	url;
 	sessionId;
 	nextId = 1;
 	config;
 	authToken;
-	constructor(config, baseUrl) {
+	constructor(config, url) {
 		this.config = config;
-		this.baseUrl = baseUrl;
+		this.url = url;
 	}
-	/**
-	* Initialize the MCP session. Must be called before any other method.
-	*/
+	/** Initialize the MCP session. Must be called before any other method. */
 	async initialize() {
 		const credential = await resolveCredential(this.config);
 		this.authToken = credential.token;
@@ -569,15 +601,9 @@ var McpClient = class {
 		}
 		await this.notify("notifications/initialized");
 	}
-	/**
-	* List available tools from the MCP server.
-	*/
 	async listTools() {
 		return (await this.rpc("tools/list")).tools || [];
 	}
-	/**
-	* Call a tool on the MCP server.
-	*/
 	async callTool(name, args) {
 		return await this.rpc("tools/call", {
 			name,
@@ -613,11 +639,11 @@ var McpClient = class {
 		if (this.authToken) headers["Authorization"] = `Bearer ${this.authToken}`;
 		if (this.sessionId) headers["Mcp-Session-Id"] = this.sessionId;
 		if (this.config.verbose) {
-			console.error(`> POST ${this.baseUrl}`);
+			console.error(`> POST ${this.url}`);
 			console.error(`> Method: ${body.method}`);
 		}
 		const timeoutMs = this.config.timeout * 1e3;
-		const res = await fetch(this.baseUrl, {
+		const res = await fetch(this.url, {
 			method: "POST",
 			headers,
 			body: JSON.stringify(body),
@@ -644,11 +670,13 @@ async function* parseSSE(response) {
 	if (!reader) return;
 	const decoder = new TextDecoder();
 	let buffer = "";
+	const MAX_SSE_BUFFER = 16 * 1024 * 1024;
 	try {
 		while (true) {
 			const { done, value } = await reader.read();
 			if (done) break;
 			buffer += decoder.decode(value, { stream: true });
+			if (buffer.length > MAX_SSE_BUFFER) throw new BailianError("SSE stream exceeded the maximum buffer size.", ExitCode.GENERAL);
 			const lines = buffer.split("\n");
 			buffer = lines.pop() || "";
 			let event = {};
@@ -670,6 +698,7 @@ async function* parseSSE(response) {
 				switch (field) {
 					case "data":
 						event.data = event.data !== void 0 ? `${event.data}\n${value}` : value;
+						if (event.data.length > MAX_SSE_BUFFER) throw new BailianError("SSE event exceeded the maximum buffer size.", ExitCode.GENERAL);
 						break;
 					case "event":
 						event.event = value;
@@ -740,6 +769,37 @@ async function callConsoleGateway(config, token, { api, data, region = "cn-beiji
 	return res.json();
 }
 //#endregion
+//#region src/console/models.ts
+const MODEL_LIST_API = "zeldaHttp.dashscopeModel./zelda/api/v1/modelCenter/listFoundationModels";
+async function fetchModelList(config, token, params = {}) {
+	const { pageNo = 1, pageSize = 50, name = "", providers = [], capabilities = [], region = "cn-beijing" } = params;
+	const result = await callConsoleGateway(config, token, {
+		api: MODEL_LIST_API,
+		data: { input: {
+			pageNo,
+			pageSize,
+			name,
+			providers,
+			inferenceProviders: [],
+			features: [],
+			group: true,
+			capabilities,
+			contextWindows: []
+		} },
+		region
+	});
+	const responseData = result?.data?.DataV2?.data ?? result?.data ?? {};
+	const total = responseData?.data?.total ?? responseData?.total ?? 0;
+	const groups = responseData?.data?.list ?? responseData?.list ?? [];
+	const models = [];
+	for (const group of groups) if (group.items?.length) for (const item of group.items) models.push(item);
+	else models.push(group);
+	return {
+		total,
+		models
+	};
+}
+//#endregion
 //#region src/files/upload.ts
 /**
 * Upload local files to DashScope temporary OSS storage.
@@ -999,11 +1059,6 @@ function generateToolSchema(cmd) {
 	return schema;
 }
 //#endregion
-//#region src/utils/token.ts
-function maskToken(token) {
-	return token.length > 8 ? `${token.slice(0, 4)}...${token.slice(-4)}` : "***";
-}
-//#endregion
 //#region src/utils/env.ts
 /**
 * Environment detection utilities for bailian-cli.
@@ -1053,6 +1108,35 @@ function stripUndefined(obj) {
 	return obj;
 }
 //#endregion
+//#region src/utils/boolean-flag.ts
+/** Parse true/false from CLI flags (e.g. `--watermark <bool>`). */
+function parseBooleanValue(value, label = "boolean") {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		const v = value.trim().toLowerCase();
+		if (v === "true") return true;
+		if (v === "false") return false;
+	}
+	throw new BailianError(`Invalid ${label} value "${String(value)}". Use true or false.`, ExitCode.USAGE);
+}
+function parseOptionalBooleanValue(value, label = "boolean") {
+	if (value === void 0 || value === null) return void 0;
+	return parseBooleanValue(value, label);
+}
+/**
+* Resolve a tri-state boolean CLI flag (`--name <bool>`).
+* Returns `defaultWhenUnset` when the flag is omitted.
+*/
+function resolveBooleanFlag(flagValue, defaultWhenUnset, label = "boolean") {
+	const fromFlag = parseOptionalBooleanValue(flagValue, label);
+	if (fromFlag !== void 0) return fromFlag;
+	return defaultWhenUnset;
+}
+/** Resolve `--watermark` flag; default true when unset. */
+function resolveWatermark(flagValue) {
+	return parseOptionalBooleanValue(flagValue, "watermark") ?? true;
+}
+//#endregion
 //#region src/telemetry/event.ts
 function createTrackingEvent(opts) {
 	const event = {
@@ -1801,9 +1885,7 @@ var require_tracker = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 							gokey: encodeURIComponent(e),
 							gmkey: "EXP"
 						})
-					}).catch(function(e) {
-						console.warn("send fail", e);
-					});
+					}).catch(function() {});
 				}).catch(function(t) {
 					n._offlineQueue.length > 500 && n._offlineQueue.shift(), n._offlineQueue.push(e);
 				});
@@ -1946,7 +2028,7 @@ async function localSink(event) {
 		try {
 			if (statSync(path).size > MAX_FILE_SIZE) unlinkSync(path);
 		} catch {}
-		appendFileSync(path, JSON.stringify(event) + "\n");
+		appendFileSync(path, JSON.stringify(event) + "\n", { mode: 384 });
 	} catch {}
 }
 async function remoteSink(event) {
@@ -2013,7 +2095,6 @@ const PARAM_ALLOWLIST = new Set([
 	"noWait",
 	"textOnly",
 	"promptExtend",
-	"noPromptExtend",
 	"enableSsml",
 	"watermark",
 	"hasThoughts",
@@ -2078,4 +2159,1155 @@ async function trackCommandExecution(config, commandPath, flags, fn) {
 	}
 }
 //#endregion
-export { BAILIAN_HOST, BailianError, CHANNEL, CONSOLE_GATEWAY_NO_TOKEN_MESSAGE, DOCS_HOSTS, ExitCode, GLOBAL_OPTIONS, McpClient, REGIONS, SOURCE_CONFIG, TAGS, appCompletionEndpoint, callConsoleGateway, chatEndpoint, clearApiKey, createTrackingEvent, defineCommand, detectOutputFormat, ensureConfigDir, flushTelemetry, formatErrorJson, formatJson, formatOutput, formatText, generateFilename, generateToolSchema, getConfigDir, getConfigPath, getCredentialsPath, imageEndpoint, imageSyncEndpoint, isCI, isInteractive, isLocalFile, loadApiKeyFromConfig, loadConfig, localSink, mapApiError, maskToken, mcpWebSearchEndpoint, memoryAddEndpoint, memoryListEndpoint, memoryNodeEndpoint, memorySearchEndpoint, parseConfigFile, parseSSE, profileSchemaEndpoint, readConfigFile, remoteSink, request, requestJson, resolveConsoleGatewayCredential, resolveCredential, resolveFileUrl, resolveOutputDir, saveApiKeyToConfig, signRequest, speechRecognizeEndpoint, speechSynthesizeEndpoint, stripUndefined, taskEndpoint, trackCommandExecution, trackingHeaders, uploadFile, userProfileEndpoint, videoGenerateEndpoint, writeConfigFile };
+//#region src/advisor/sources/api.ts
+const PAGE_SIZE = 50;
+function toModelProfile(item) {
+	if (!item.model) return null;
+	const meta = item.inferenceMetadata;
+	return {
+		model: item.model,
+		name: item.name ?? item.model,
+		description: item.description ?? item.shortDescription ?? "",
+		shortDescription: item.shortDescription,
+		provider: item.provider ?? "",
+		capabilities: item.capabilities ?? [],
+		features: item.features ?? [],
+		category: item.category,
+		contextWindow: item.contextWindow ?? void 0,
+		maxOutputTokens: item.maxOutputTokens ?? void 0,
+		maxInputTokens: item.maxInputTokens ?? void 0,
+		docUrl: item.docUrl,
+		collectionTag: item.collectionTag,
+		inferenceMetadata: meta,
+		prices: item.prices,
+		qpmInfo: item.qpmInfo,
+		versionTag: item.versionTag,
+		openSource: item.openSource
+	};
+}
+var ApiSource = class {
+	name = "api";
+	constructor(config) {
+		this.config = config;
+	}
+	available() {
+		return true;
+	}
+	async load() {
+		const first = await fetchModelList(this.config, "", {
+			pageNo: 1,
+			pageSize: PAGE_SIZE
+		});
+		const allRaw = [...first.models];
+		const totalPages = Math.ceil(first.total / PAGE_SIZE);
+		for (let page = 2; page <= totalPages; page++) {
+			const result = await fetchModelList(this.config, "", {
+				pageNo: page,
+				pageSize: PAGE_SIZE
+			});
+			allRaw.push(...result.models);
+		}
+		return allRaw.map(toModelProfile).filter((profile) => profile !== null);
+	}
+};
+//#endregion
+//#region src/advisor/sources/catalog.ts
+const SKILL_DIR_NAME = "skills/doc-llm-wiki";
+const MODELS_FILE = "models.jsonl";
+function getCatalogDir() {
+	return join$1(getConfigDir(), SKILL_DIR_NAME);
+}
+function getCatalogPath() {
+	return join$1(getCatalogDir(), MODELS_FILE);
+}
+function getMonorepoModelsDir() {
+	return join$1(dirname(fileURLToPath(import.meta.url)), "../../../../../skills/doc-llm-wiki/models");
+}
+function fromJsonlRecord(raw) {
+	if (!raw.model || typeof raw.model !== "string") return null;
+	return {
+		model: raw.model,
+		name: raw.name ?? raw.model,
+		description: raw.description ?? "",
+		provider: raw.provider ?? "",
+		capabilities: raw.capabilities ?? [],
+		features: raw.features ?? [],
+		contextWindow: raw.contextWindow,
+		maxOutputTokens: raw.maxOutputTokens,
+		docUrl: raw.docUrl,
+		inferenceMetadata: raw.inferenceMetadata,
+		shortDescription: raw.shortDescription,
+		category: raw.category,
+		collectionTag: raw.collectionTag,
+		maxInputTokens: raw.maxInputTokens,
+		prices: raw.prices,
+		qpmInfo: raw.qpmInfo,
+		versionTag: raw.versionTag,
+		openSource: raw.openSource,
+		family: raw.family,
+		familyName: raw.familyName
+	};
+}
+function readJsonlModels(filePath) {
+	const lines = readFileSync$1(filePath, "utf-8").split("\n").filter(Boolean);
+	const models = [];
+	for (const line of lines) try {
+		const record = fromJsonlRecord(JSON.parse(line));
+		if (record) models.push(record);
+	} catch {}
+	return models;
+}
+function installFromMonorepo() {
+	const src = getMonorepoModelsDir();
+	if (!existsSync$1(join$1(src, MODELS_FILE))) return false;
+	const dest = getCatalogDir();
+	try {
+		mkdirSync$1(dest, { recursive: true });
+		cpSync(src, dest, { recursive: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+var CatalogSource = class {
+	name = "catalog";
+	options;
+	constructor(options) {
+		this.options = options ?? {};
+	}
+	available() {
+		return existsSync$1(getCatalogPath());
+	}
+	async load() {
+		if (!this.available()) {
+			this.options.onPrepareStart?.();
+			if (!installFromMonorepo()) return [];
+		}
+		return readJsonlModels(getCatalogPath());
+	}
+};
+//#endregion
+//#region src/advisor/cache.ts
+async function getModels(config, options) {
+	const sources = [new CatalogSource({ onPrepareStart: options?.onPrepareStart }), new ApiSource(config)];
+	for (const source of sources) if (source.available()) {
+		const models = await source.load();
+		if (models.length > 0) return models;
+	}
+	const models = await sources[0].load();
+	if (models.length > 0) return models;
+	throw new BailianError("No model data available.", ExitCode.GENERAL);
+}
+//#endregion
+//#region src/advisor/types.ts
+const Modalities = {
+	Text: "Text",
+	Image: "Image",
+	Video: "Video",
+	Audio: "Audio"
+};
+const Complexities = {
+	Single: "single",
+	Pipeline: "pipeline"
+};
+const Budgets = {
+	Low: "low",
+	Medium: "medium",
+	High: "high"
+};
+const ContextNeeds = {
+	Standard: "standard",
+	Large: "large",
+	ExtraLarge: "extra-large"
+};
+const QualityPreferences = {
+	Flagship: "flagship",
+	Balanced: "balanced",
+	CostOptimized: "cost-optimized"
+};
+const Capabilities = {
+	TG: "TG",
+	Reasoning: "Reasoning",
+	VU: "VU",
+	IG: "IG",
+	VG: "VG",
+	TTS: "TTS",
+	ASR: "ASR",
+	RealtimeASR: "Realtime-ASR",
+	RealtimeTTS: "Realtime-Text-to-Speech",
+	RealtimeAudioTranslate: "Realtime-Audio-Translate",
+	RealtimeOmni: "Realtime-Omni",
+	MultimodalOmni: "Multimodal-Omni",
+	ME: "ME",
+	TR: "TR",
+	ThreeDGeneration: "3D-generation"
+};
+const Features = {
+	FunctionCalling: "function-calling",
+	WebSearch: "web-search",
+	StructuredOutputs: "structured-outputs",
+	PrefixCompletion: "prefix-completion"
+};
+const ModelCategories = {
+	Flagship: "Flagship",
+	CostOptimized: "Cost-optimized"
+};
+//#endregion
+//#region src/advisor/constants/prompts.ts
+const INTENT_MODEL = "qwen-turbo";
+const RANKING_MODEL = "qwen3.6-flash";
+const RANKING_MODEL_FAST = "qwen-turbo";
+const INTENT_SYSTEM_PROMPT = `你是一个意图分析器。根据用户的需求描述，先理解用户场景，再提取结构化信息。
+
+## 分析步骤
+1. 用一句话总结用户的核心需求（taskSummary），要体现具体场景而非泛泛描述
+2. 推断场景特征（scenarioHints），例如：["需要低延迟","面向C端用户","高并发","对话式交互","离线批处理","需要精准度"]
+3. 基于场景特征推断 budget 和 qualityPreference
+   - 只在用户明确表达或场景强烈暗示时偏离默认值
+   - 用户明确说"低成本"、"便宜"、"省钱" → budget:"low"
+   - 用户明确说"最好的"、"高精度"、"不计成本" → qualityPreference:"flagship"
+   - 场景本身有强约束时才推断：如"日均百万请求的客服" → budget:"low"（高并发=成本敏感）
+   - 其他情况保持 budget:"medium", qualityPreference:"balanced"
+4. 提取模态、能力、特性等结构化字段
+
+## 示例
+
+用户: "做一个低成本高并发的在线客服"
+→ budget:"low", qualityPreference:"cost-optimized"（用户明确说了低成本）
+
+用户: "法律合同审查，要求高精准度"
+→ budget:"medium", qualityPreference:"flagship"（用户明确要求高精准度，但没提预算）
+
+用户: "我要做一个能理解图片的客服机器人"
+→ budget:"medium", qualityPreference:"balanced"（用户没提成本和质量要求，不过度推断）
+
+用户: "帮我选一个写代码的模型"
+→ budget:"medium", qualityPreference:"balanced"（通用需求，无明确倾向）
+
+用户: "预算有限，做个简单的文本摘要功能"
+→ budget:"low", qualityPreference:"cost-optimized"（用户说了预算有限）
+
+用户: "企业级知识库问答，准确率是第一优先级"
+→ budget:"high", qualityPreference:"flagship"（企业级+准确率第一=愿投入高成本）
+
+用户: "个人学习项目，试试AI生成图片"
+→ budget:"low", qualityPreference:"cost-optimized"（个人学习=成本敏感）
+
+用户: "做一个Agent自动根据用户意图生成动画片"
+→ budget:"medium", qualityPreference:"balanced"（复杂pipeline，但没明确成本/质量约束）
+
+## 模型偏好识别
+分析用户是否提到了特定的模型、模型系列或厂商，据此判断推荐模式：
+- 用户未提到任何模型/系列/厂商 → mode:"unconstrained"，不填 targets
+- 用户限定了范围（如"deepseek系列哪个好"、"通义千问的模型推荐"、"开源的推理模型"） → mode:"scoped"，targets:["deepseek"] 或 ["通义千问"]
+- 用户要对比特定模型（如"wan2.6和wan2.7哪个好"、"qwen-max和deepseek-v3对比"、"qwen-max适合做法律分析吗"） → mode:"comparison"，targets:["wan2.6","wan2.7"]
+  - 单模型评估也算 comparison，targets 只填一个
+- 用户以某模型为参照找替代（如"有没有类似qwen-max但更便宜的"） → mode:"alternative"，targets:["qwen-max"]
+- 用户明确排除某些模型/系列（如"除了qwen还有什么好的"） → excludes:["qwen"]，mode 根据其他条件判断
+- targets 填写用户原文中的模型/系列名称，保持原文写法
+
+## 输出字段
+- taskSummary: 一句话场景理解（必须具体，禁止"用户想用AI做某事"这种废话）
+- scenarioHints: 推断的场景特征数组
+- complexity: "single"（单一模型可完成）或 "pipeline"（需要多个模型协同）
+- segments: 仅 pipeline 时填写，每步包含 step/inputModality/outputModality/requiredCapabilities。
+  - step 必须是一句话描述该步骤在用户任务中解决的具体问题，例如"解析天气预报数据，生成适合视频制作的场景描述文本"，禁止用编号或泛化的模态标签
+  - segments 必须形成模态链路：每步的 inputModality 应包含上一步的 outputModality，确保上下游数据可以衔接
+- inputModality: 用户输入涉及的模态 ["Text","Image","Video","Audio"]
+- outputModality: 期望输出的模态
+- requiredCapabilities: 需要的能力。可选代码（必须严格使用，不要自创）：
+  TG=文本生成, Reasoning=推理, VU=视觉理解, IG=图像生成, VG=视频生成,
+  TTS=语音合成, ASR=语音识别, Realtime-ASR=实时语音识别,
+  Realtime-Text-to-Speech=实时语音合成, Realtime-Audio-Translate=实时音频翻译,
+  Realtime-Omni=实时全模态, Multimodal-Omni=全模态, ME=多模态嵌入,
+  TR=翻译, 3D-generation=3D生成
+- requiredFeatures: 需要的特性 (function-calling, web-search, structured-outputs, prefix-completion)
+- budget: "low"/"medium"/"high"（基于场景推断，不要默认 medium）
+- contextNeed: "standard"/"large"/"extra-large"
+- qualityPreference: "flagship"/"balanced"/"cost-optimized"（基于场景推断，不要默认 balanced）
+- modelPreference: { mode, targets?, excludes? }（见上方"模型偏好识别"）
+
+只输出 JSON，不要有其他文字。`;
+const SINGLE_SYSTEM_PROMPT = `你是阿里云百炼平台的模型推荐顾问。从以下候选模型中选出最佳推荐。
+
+## 背景
+系统已根据用户意图预筛选了候选模型，你只需从中精选并排序。
+意图分析中包含 budget 和 qualityPreference 字段，这代表了用户的实际需求层次。
+
+## 推荐策略
+
+推荐 3 个不同档次的模型，但排序必须反映用户的真实需求：
+
+- 推荐 #1（最佳推荐）：根据 budget 和 qualityPreference 判断哪个档次最适合用户，把那个档次的最佳模型放在第一位
+- 推荐 #2（次优选择）：另一个档次中值得考虑的模型，说明与 #1 相比的 tradeoff
+- 推荐 #3（备选参考）：第三个视角的选择，说明适用场景差异
+
+关键原则：
+- budget:"low" / qualityPreference:"cost-optimized" → 推荐 #1 应该是性价比最高的模型，而非旗舰模型
+- budget:"high" / qualityPreference:"flagship" → 推荐 #1 应该是能力最强的旗舰模型
+- budget:"medium" / qualityPreference:"balanced" → 推荐 #1 应该是综合匹配度最高的模型，不预设档次偏好
+
+每个推荐都必须说明该模型为什么适合（或作为备选为什么值得考虑），理由必须关联用户的具体需求。
+
+## 规则
+- 只能推荐候选列表中的模型，严禁推荐列表外的模型
+- 严禁使用泛泛的推荐理由（如"性能强大"、"综合能力好"、"效果不错"），每条 reason 必须说明该模型解决用户任务中的什么具体问题
+- 三个推荐的理由不允许雷同，每个必须从不同维度论证
+- 有定价信息时：结合 budget 字段权衡，把最符合用户预算的放在最前面
+- 有家族信息时：避免推荐同一家族的多个模型，优先推荐稳定版本
+- 有版本标签时：优先推荐 stable/latest 版本，除非用户明确需要特定版本
+- 没有增强字段的模型：按能力和描述排序即可，不因缺少信息而降权
+- 如果没有合适的模型，返回空数组
+- 如果你认为该需求实际需要多模型协同完成（pipeline），可以输出 type:"pipeline" 格式
+- 输出严格 JSON，不要输出其他内容
+
+## 输出格式
+
+单一任务：
+{"type":"single","recommendations":[{"model":"模型ID","reason":"推荐理由","highlights":["亮点"]}]}
+
+复合任务（仅当你确信需要多模型协同时）：
+{"type":"pipeline","summary":"一句话方案描述","steps":[{"step":"步骤描述","recommendations":[{"model":"模型ID","reason":"选择理由","highlights":["亮点"]}]}]}`;
+const PIPELINE_SYSTEM_PROMPT = `你是阿里云百炼平台的模型推荐顾问。用户需求已被拆解为多步骤流水线，请为每步选出最佳模型。
+
+## 背景
+系统已根据各步骤需求预筛选了候选模型。
+意图分析中包含 budget 和 qualityPreference 字段，这代表了用户的实际需求层次。
+
+## 推荐策略
+
+每步推荐 3 个不同档次的模型，但排序必须反映用户的真实需求：
+
+- 推荐 #1（最佳推荐）：根据 budget 和 qualityPreference 判断哪个档次最适合用户，把那个档次的最佳模型放在第一位
+- 推荐 #2（次优选择）：另一个档次中值得考虑的模型，说明 tradeoff
+- 推荐 #3（备选参考）：第三个视角的选择，说明适用场景差异
+
+关键原则：
+- budget:"low" / qualityPreference:"cost-optimized" → 推荐 #1 应该是性价比最高的模型
+- budget:"high" / qualityPreference:"flagship" → 推荐 #1 应该是能力最强的旗舰模型
+- budget:"medium" / qualityPreference:"balanced" → 推荐 #1 应该是综合匹配度最高的模型
+
+## 规则
+- 只能推荐候选列表中的模型
+- 每步推荐多个模型，按优先级排序，每个推荐给出简短理由和关键亮点
+- step 字段必须用一句话描述该步骤在用户任务中解决的具体问题，禁止用编号或泛化的模态标签（如"输出: Text"）
+- 严禁使用泛泛的推荐理由，每条 reason 必须说明该模型在这一步解决用户任务中的什么具体问题
+- 有定价信息时：结合 budget 字段权衡，把最符合用户预算的放在最前面
+- 有家族信息时：避免在相邻步骤使用同一家族的不同规格模型，除非确实需要
+- 没有增强字段的模型：按能力和描述排序即可，不因缺少信息而降权
+- 相邻步骤的模型必须模态兼容：上一步模型的输出模态必须被下一步模型的输入模态支持
+- 如果你认为该需求其实单模型可以完成，可以输出 type:"single" 格式
+- 输出严格 JSON
+
+## 输出格式
+
+{"type":"pipeline","summary":"一句话方案描述","steps":[{"step":"该步骤在用户任务中解决的具体问题","recommendations":[{"model":"模型ID","reason":"该模型如何解决这一步的具体问题","highlights":["亮点"]}]}]}
+
+或者（如果你认为单模型即可）：
+{"type":"single","recommendations":[{"model":"模型ID","reason":"推荐理由","highlights":["亮点"]}]}`;
+const COMPARISON_SYSTEM_PROMPT = `你是阿里云百炼平台的模型对比顾问。用户想对比特定模型，请根据使用场景进行对比分析。
+
+## 背景
+用户指定了要对比的模型，系统已将这些模型和相关候选预筛选到列表中。
+意图分析中的 modelPreference.targets 是用户要对比的模型。
+
+## 对比策略
+- 用户指定的模型必须全部出现在推荐结果中，按适合程度排序
+- 每个模型的 reason 必须是对比性的，说明该模型相对于其他对比模型的优势和劣势
+- 如果候选中有比用户指定的更合适的模型，可以额外推荐，但用户指定的必须优先包含
+- 单模型评估场景（targets 只有一个）：评估该模型是否适合用户需求，同时推荐更优的替代
+
+## 规则
+- 只能推荐候选列表中的模型
+- reason 必须包含对比视角：该模型相比其他模型在哪些方面更好/更差
+- highlights 突出各模型的差异化特点
+- 输出严格 JSON，不要输出其他内容
+
+## 输出格式
+{"type":"single","recommendations":[{"model":"模型ID","reason":"对比分析理由","highlights":["差异化亮点"]}]}`;
+const ALTERNATIVE_SYSTEM_PROMPT = `你是阿里云百炼平台的模型替代顾问。用户以某个模型为参照，寻找替代方案。
+
+## 背景
+用户以某个模型为参照点，想找到在特定维度上更优的替代方案（如更便宜、更快、更强）。
+意图分析中的 modelPreference.targets 是参照模型。
+
+## 替代策略
+- 推荐 #1：如果参照模型在候选中，先评估它是否满足用户需求，给出其基本定位
+- 推荐 #2~#3：推荐替代方案，reason 必须说明相比参照模型在用户关注维度上的 tradeoff
+- 关注用户提到的替代维度（如"更便宜"→重点对比定价，"更强"→重点对比能力）
+
+## 规则
+- 只能推荐候选列表中的模型
+- 参照模型必须包含在结果中（如果在候选列表中）
+- 替代推荐的 reason 必须说明与参照模型的具体差异
+- 避免推荐和参照模型同系列的其他版本（除非确实有显著差异）
+- 输出严格 JSON，不要输出其他内容
+
+## 输出格式
+{"type":"single","recommendations":[{"model":"模型ID","reason":"替代分析理由","highlights":["差异化亮点"]}]}`;
+//#endregion
+//#region src/advisor/constants/defaults.ts
+const DEFAULT_INTENT = {
+	complexity: Complexities.Single,
+	taskSummary: "",
+	scenarioHints: [],
+	inputModality: [],
+	outputModality: [],
+	requiredCapabilities: [Capabilities.TG],
+	requiredFeatures: [],
+	budget: Budgets.Medium,
+	contextNeed: ContextNeeds.Standard,
+	qualityPreference: QualityPreferences.Balanced,
+	confidence: 0
+};
+//#endregion
+//#region src/advisor/intent.ts
+async function analyzeIntent(config, input) {
+	const url = chatEndpoint(config.baseUrl);
+	const body = {
+		model: INTENT_MODEL,
+		messages: [{
+			role: "system",
+			content: INTENT_SYSTEM_PROMPT
+		}, {
+			role: "user",
+			content: input
+		}],
+		max_tokens: 1024,
+		temperature: 0
+	};
+	try {
+		const jsonMatch = ((await requestJson(config, {
+			url,
+			method: "POST",
+			body,
+			timeout: 5e3
+		})).choices?.[0]?.message?.content ?? "").match(/\{[\s\S]*\}/);
+		if (!jsonMatch) return DEFAULT_INTENT;
+		const parsed = JSON.parse(jsonMatch[0]);
+		const VALID_MODES = [
+			"scoped",
+			"comparison",
+			"alternative"
+		];
+		const rawPref = parsed.modelPreference;
+		const modelPreference = rawPref && typeof rawPref === "object" ? {
+			mode: VALID_MODES.includes(rawPref.mode) ? rawPref.mode : "unconstrained",
+			targets: Array.isArray(rawPref.targets) ? rawPref.targets : void 0,
+			excludes: Array.isArray(rawPref.excludes) ? rawPref.excludes : void 0
+		} : void 0;
+		return {
+			complexity: parsed.complexity === Complexities.Pipeline ? Complexities.Pipeline : Complexities.Single,
+			taskSummary: typeof parsed.taskSummary === "string" ? parsed.taskSummary : "",
+			scenarioHints: Array.isArray(parsed.scenarioHints) ? parsed.scenarioHints : [],
+			segments: Array.isArray(parsed.segments) ? parsed.segments.map((seg) => ({
+				step: seg.step ?? "",
+				inputModality: Array.isArray(seg.inputModality) ? seg.inputModality : [],
+				outputModality: Array.isArray(seg.outputModality) ? seg.outputModality : [],
+				requiredCapabilities: Array.isArray(seg.requiredCapabilities) ? seg.requiredCapabilities : []
+			})) : void 0,
+			inputModality: Array.isArray(parsed.inputModality) ? parsed.inputModality : [],
+			outputModality: Array.isArray(parsed.outputModality) ? parsed.outputModality : [],
+			requiredCapabilities: Array.isArray(parsed.requiredCapabilities) ? parsed.requiredCapabilities : [],
+			requiredFeatures: Array.isArray(parsed.requiredFeatures) ? parsed.requiredFeatures : [],
+			budget: parsed.budget ?? DEFAULT_INTENT.budget,
+			contextNeed: parsed.contextNeed ?? DEFAULT_INTENT.contextNeed,
+			qualityPreference: parsed.qualityPreference ?? DEFAULT_INTENT.qualityPreference,
+			confidence: 1,
+			modelPreference
+		};
+	} catch {
+		return DEFAULT_INTENT;
+	}
+}
+//#endregion
+//#region src/advisor/constants/scoring.ts
+const SNAPSHOT_DATE_RE = /-\d{4}-\d{2}-\d{2}$/;
+const GENERATION_CAPS = new Set([
+	Capabilities.IG,
+	Capabilities.VG,
+	Capabilities.TTS,
+	Capabilities.RealtimeTTS,
+	Capabilities.ThreeDGeneration
+]);
+const TEXT_CAPS = new Set([
+	Capabilities.TG,
+	Capabilities.Reasoning,
+	Capabilities.ASR,
+	Capabilities.RealtimeASR,
+	Capabilities.RealtimeAudioTranslate,
+	Capabilities.TR,
+	Capabilities.ME
+]);
+const CONTEXT_THRESHOLDS = {
+	standard: 0,
+	large: 32e3,
+	"extra-large": 128e3
+};
+//#endregion
+//#region src/advisor/recall.ts
+function hasMultiDomainCapabilities(caps) {
+	let hasGen = false;
+	let hasText = false;
+	for (const cap of caps) {
+		if (GENERATION_CAPS.has(cap)) hasGen = true;
+		if (TEXT_CAPS.has(cap)) hasText = true;
+	}
+	return hasGen && hasText;
+}
+function deduplicateSnapshots(models) {
+	const mainModels = new Set(models.map(({ model }) => model));
+	return models.filter(({ model }) => {
+		const base = model.replace(SNAPSHOT_DATE_RE, "");
+		if (base === model) return true;
+		return !mainModels.has(base);
+	});
+}
+function matchesModality(model, inputModality, outputModality) {
+	const modelInput = model.inferenceMetadata?.request_modality ?? [];
+	const modelOutput = model.inferenceMetadata?.response_modality ?? [];
+	if (inputModality.length > 0) {
+		if (!inputModality.some((mod) => modelInput.includes(mod))) return false;
+	}
+	if (outputModality.length > 0) {
+		if (!outputModality.some((mod) => modelOutput.includes(mod))) return false;
+	}
+	return true;
+}
+function matchesUpstream(model, upstreamOutput) {
+	if (upstreamOutput.length === 0) return true;
+	const accepts = model.inferenceMetadata?.request_modality ?? [];
+	return upstreamOutput.some((mod) => accepts.includes(mod));
+}
+function scoreModel(model, intent) {
+	const { requiredCapabilities, requiredFeatures, contextNeed, qualityPreference } = intent;
+	const { capabilities, features, contextWindow, category } = model;
+	let score = 0;
+	for (const cap of requiredCapabilities) if (capabilities.includes(cap)) score += 10;
+	for (const feat of requiredFeatures) if (features.includes(feat)) score += 5;
+	const ctxThreshold = CONTEXT_THRESHOLDS[contextNeed];
+	if (ctxThreshold > 0 && (contextWindow ?? 0) >= ctxThreshold) score += 8;
+	if (qualityPreference === QualityPreferences.Flagship && category === ModelCategories.Flagship) score += 15;
+	else if (qualityPreference === QualityPreferences.CostOptimized && category === ModelCategories.CostOptimized) score += 15;
+	else if (qualityPreference === QualityPreferences.Balanced) {
+		if (category === ModelCategories.Flagship) score += 5;
+	}
+	return score;
+}
+function scoreAndRank(models, intent, limit) {
+	return models.map((model) => ({
+		model,
+		score: scoreModel(model, intent)
+	})).sort((left, right) => right.score - left.score).slice(0, limit);
+}
+function candidateIds(candidates) {
+	return new Set(candidates.map(({ model }) => model.model));
+}
+function capByFamily(candidates, cap) {
+	const counts = /* @__PURE__ */ new Map();
+	const kept = [];
+	const overflow = [];
+	for (const candidate of candidates) {
+		const family = candidate.model.family;
+		if (!family) {
+			kept.push(candidate);
+			continue;
+		}
+		const cur = counts.get(family) ?? 0;
+		if (cur < cap) {
+			kept.push(candidate);
+			counts.set(family, cur + 1);
+		} else overflow.push(candidate);
+	}
+	if (kept.length >= 10) return kept;
+	return [...kept, ...overflow.slice(0, 10 - kept.length)];
+}
+function deduplicateCandidates(candidates, excludeIds) {
+	const seen = new Set(excludeIds);
+	return candidates.filter((candidate) => {
+		if (seen.has(candidate.model.model)) return false;
+		seen.add(candidate.model.model);
+		return true;
+	});
+}
+function computeRemaining(models, intent, excludeIds) {
+	if (excludeIds.size >= 10) return [];
+	return scoreAndRank(models.filter(({ model }) => !excludeIds.has(model)), intent, 10 - excludeIds.size);
+}
+function recallForSegment(models, segment, upstreamOutput, budget, qualityPreference) {
+	const { inputModality, outputModality, requiredCapabilities } = segment;
+	const segmentIntent = {
+		complexity: Complexities.Single,
+		taskSummary: "",
+		scenarioHints: [],
+		inputModality,
+		outputModality,
+		requiredCapabilities,
+		requiredFeatures: [],
+		budget,
+		contextNeed: ContextNeeds.Standard,
+		qualityPreference,
+		confidence: 1
+	};
+	let candidates = models.filter((profile) => matchesModality(profile, inputModality, outputModality) && matchesUpstream(profile, upstreamOutput));
+	if (candidates.length < 5) candidates = models.filter((profile) => matchesModality(profile, inputModality, outputModality));
+	if (candidates.length < 5) candidates = models;
+	return scoreAndRank(candidates, segmentIntent, 5);
+}
+function recallCandidates(models, intent) {
+	models = deduplicateSnapshots(models);
+	let result;
+	if (intent.complexity === Complexities.Pipeline && intent.segments?.length) {
+		let results = [];
+		for (const [segIdx, segment] of intent.segments.entries()) {
+			const upstreamOutput = segIdx === 0 ? [] : intent.segments[segIdx - 1].outputModality;
+			const unique = deduplicateCandidates(recallForSegment(models, segment, upstreamOutput, intent.budget, intent.qualityPreference), candidateIds(results));
+			results = [...results, ...unique];
+		}
+		const remaining = computeRemaining(models, intent, candidateIds(results));
+		result = [...results, ...remaining];
+	} else if (hasMultiDomainCapabilities(intent.requiredCapabilities)) result = recallCrossDomain(models, intent);
+	else {
+		let hardFiltered = models.filter((profile) => matchesModality(profile, intent.inputModality, intent.outputModality));
+		if (hardFiltered.length < 5) hardFiltered = models;
+		result = scoreAndRank(hardFiltered, intent, 50);
+	}
+	return capByFamily(result, 3);
+}
+function recallCrossDomain(models, intent) {
+	const perDomain = Math.ceil(50 / 2);
+	const genCaps = intent.requiredCapabilities.filter((cap) => GENERATION_CAPS.has(cap));
+	const textCaps = intent.requiredCapabilities.filter((cap) => TEXT_CAPS.has(cap));
+	let results = [];
+	if (genCaps.length > 0) results = scoreAndRank(models.filter((profile) => genCaps.some((cap) => profile.capabilities.includes(cap))), intent, perDomain);
+	if (textCaps.length > 0) {
+		const excludeIds = candidateIds(results);
+		const textIntent = {
+			...intent,
+			requiredCapabilities: textCaps
+		};
+		const textModels = models.filter((profile) => !excludeIds.has(profile.model) && textCaps.some((cap) => profile.capabilities.includes(cap)));
+		results = [...results, ...scoreAndRank(textModels, textIntent, perDomain)];
+	}
+	const remaining = computeRemaining(models, intent, candidateIds(results));
+	return [...results, ...remaining];
+}
+//#endregion
+//#region src/advisor/embedding.ts
+const EMBEDDING_MODEL = "text-embedding-v4";
+const EMBEDDINGS_FILE = "models-embeddings.json";
+const BATCH_SIZE = 10;
+function skillDataDir() {
+	return join$1(getConfigDir(), "skills/doc-llm-wiki");
+}
+function embeddingsPath() {
+	return join$1(skillDataDir(), EMBEDDINGS_FILE);
+}
+function loadModelEmbeddings() {
+	const path = embeddingsPath();
+	if (!existsSync$1(path)) return null;
+	try {
+		return JSON.parse(readFileSync$1(path, "utf-8")).items;
+	} catch {
+		return null;
+	}
+}
+async function embedQuery(config, text) {
+	return (await requestJson(config, {
+		url: `${config.baseUrl}/compatible-mode/v1/embeddings`,
+		method: "POST",
+		body: {
+			model: EMBEDDING_MODEL,
+			input: [text],
+			dimensions: 512,
+			encoding_format: "float"
+		},
+		timeout: 1e4
+	})).data[0].embedding;
+}
+async function embedBatch(config, texts) {
+	return (await requestJson(config, {
+		url: `${config.baseUrl}/compatible-mode/v1/embeddings`,
+		method: "POST",
+		body: {
+			model: EMBEDDING_MODEL,
+			input: texts,
+			dimensions: 512,
+			encoding_format: "float"
+		},
+		timeout: 3e4
+	})).data.sort((left, right) => left.index - right.index).map((item) => item.embedding);
+}
+const CAPABILITY_LABELS = {
+	TG: "文本生成",
+	Reasoning: "推理",
+	VU: "视觉理解",
+	IG: "图像生成",
+	VG: "视频生成",
+	TTS: "语音合成",
+	ASR: "语音识别"
+};
+const MODALITY_LABELS = {
+	Text: "文本",
+	Image: "图片/图像",
+	Video: "视频",
+	Audio: "音频/语音"
+};
+function loadGroupDescriptions() {
+	const groupsDir = join$1(skillDataDir(), "groups");
+	const map = /* @__PURE__ */ new Map();
+	if (!existsSync$1(groupsDir)) return map;
+	for (const file of readdirSync(groupsDir).filter((name) => name.endsWith(".json"))) try {
+		const data = JSON.parse(readFileSync$1(join$1(groupsDir, file), "utf-8"));
+		const groupDesc = data.description ?? "";
+		if (data.items) for (const item of data.items) map.set(item.model, item.description || groupDesc);
+	} catch {}
+	return map;
+}
+function buildModelText(model, descriptions) {
+	const caps = (model.capabilities ?? []).map((cap) => CAPABILITY_LABELS[cap] ?? cap).join(", ");
+	const description = descriptions.get(model.model) || model.shortDescription || model.description || "";
+	const inputMods = (model.inferenceMetadata?.request_modality ?? []).map((mod) => MODALITY_LABELS[mod] ?? mod).join(", ");
+	const outputMods = (model.inferenceMetadata?.response_modality ?? []).map((mod) => MODALITY_LABELS[mod] ?? mod).join(", ");
+	return [
+		model.name,
+		model.model,
+		description,
+		caps ? `能力: ${caps}` : "",
+		inputMods ? `输入: ${inputMods}` : "",
+		outputMods ? `输出: ${outputMods}` : "",
+		model.features?.length ? `特性: ${model.features.join(", ")}` : "",
+		model.familyName || "",
+		model.category ? `定位: ${model.category}` : ""
+	].filter(Boolean).join(" | ");
+}
+async function buildAndCacheEmbeddings(config, models) {
+	const descriptions = loadGroupDescriptions();
+	const texts = models.map((profile) => buildModelText(profile, descriptions));
+	const allVectors = [];
+	for (let batchStart = 0; batchStart < texts.length; batchStart += BATCH_SIZE) {
+		const vectors = await embedBatch(config, texts.slice(batchStart, batchStart + BATCH_SIZE));
+		allVectors.push(...vectors);
+	}
+	const items = models.map((profile, idx) => ({
+		id: profile.model,
+		vector: allVectors[idx]
+	}));
+	const output = {
+		model: EMBEDDING_MODEL,
+		dimensions: 512,
+		count: items.length,
+		items
+	};
+	const outPath = embeddingsPath();
+	mkdirSync$1(dirname(outPath), { recursive: true });
+	writeFileSync$1(outPath, JSON.stringify(output));
+	return items;
+}
+function cosineSimilarity(vecA, vecB) {
+	let dot = 0;
+	let normA = 0;
+	let normB = 0;
+	for (let idx = 0; idx < vecA.length; idx++) {
+		dot += vecA[idx] * vecB[idx];
+		normA += vecA[idx] * vecA[idx];
+		normB += vecB[idx] * vecB[idx];
+	}
+	const denom = Math.sqrt(normA) * Math.sqrt(normB);
+	return denom === 0 ? 0 : dot / denom;
+}
+//#endregion
+//#region src/advisor/recall-semantic.ts
+let cachedEmbeddings = null;
+function getEmbeddings() {
+	if (cachedEmbeddings === null) cachedEmbeddings = loadModelEmbeddings();
+	return cachedEmbeddings;
+}
+function isSemanticAvailable() {
+	return getEmbeddings() !== null;
+}
+function matchesTarget(model, target) {
+	const needle = target.toLowerCase();
+	return [
+		model.model,
+		model.name,
+		model.family,
+		model.familyName,
+		model.provider
+	].some((field) => field?.toLowerCase().includes(needle));
+}
+function matchesAnyTarget(model, targets) {
+	return targets.some((target) => matchesTarget(model, target));
+}
+function applyExcludes(candidates, excludes) {
+	if (excludes.length === 0) return candidates;
+	return candidates.filter(({ model }) => !matchesAnyTarget(model, excludes));
+}
+function matchesSegment(model, segment) {
+	const modelIn = model.inferenceMetadata?.request_modality ?? [];
+	const modelOut = model.inferenceMetadata?.response_modality ?? [];
+	const inOk = segment.inputModality.length === 0 || segment.inputModality.some((mod) => modelIn.includes(mod));
+	const outOk = segment.outputModality.length === 0 || segment.outputModality.some((mod) => modelOut.includes(mod));
+	if (!inOk || !outOk) return false;
+	if (segment.requiredCapabilities.length === 0) return true;
+	return segment.requiredCapabilities.some((cap) => model.capabilities.includes(cap));
+}
+function rankByEmbedding(embeddings, queryVector, allowedIds, topK) {
+	return embeddings.filter((item) => allowedIds.has(item.id)).map((item) => ({
+		id: item.id,
+		similarity: cosineSimilarity(queryVector, item.vector)
+	})).sort((left, right) => right.similarity - left.similarity).slice(0, topK);
+}
+function recallScoped(models, embeddings, queryVector, preference, topK) {
+	const targets = preference.targets ?? [];
+	const scopedModels = targets.length > 0 ? models.filter((profile) => matchesAnyTarget(profile, targets)) : models;
+	const MIN_SCOPED = 5;
+	const pool = scopedModels.length >= MIN_SCOPED ? scopedModels : models;
+	const scored = rankByEmbedding(embeddings, queryVector, new Set(pool.map((profile) => profile.model)), topK);
+	const modelMap = new Map(models.map((profile) => [profile.model, profile]));
+	const results = [];
+	if (scopedModels.length < MIN_SCOPED && targets.length > 0) {
+		for (const profile of scopedModels) results.push({
+			model: profile,
+			score: 1
+		});
+		const seen = new Set(results.map(({ model }) => model.model));
+		for (const { id, similarity } of scored) {
+			if (seen.has(id)) continue;
+			const model = modelMap.get(id);
+			if (model) results.push({
+				model,
+				score: similarity
+			});
+			if (results.length >= topK) break;
+		}
+		return results;
+	}
+	for (const { id, similarity } of scored) {
+		const model = modelMap.get(id);
+		if (model) results.push({
+			model,
+			score: similarity
+		});
+	}
+	return results;
+}
+function recallComparison(models, embeddings, queryVector, preference, topK) {
+	const targets = preference.targets ?? [];
+	const modelMap = new Map(models.map((profile) => [profile.model, profile]));
+	const forced = [];
+	const forcedIds = /* @__PURE__ */ new Set();
+	for (const profile of models) if (matchesAnyTarget(profile, targets) && !forcedIds.has(profile.model)) {
+		forced.push({
+			model: profile,
+			score: 1
+		});
+		forcedIds.add(profile.model);
+	}
+	const remaining = topK - forced.length;
+	if (remaining > 0) {
+		const extra = rankByEmbedding(embeddings, queryVector, new Set(models.filter((profile) => !forcedIds.has(profile.model)).map((profile) => profile.model)), remaining);
+		for (const { id, similarity } of extra) {
+			const model = modelMap.get(id);
+			if (model) forced.push({
+				model,
+				score: similarity
+			});
+		}
+	}
+	return forced;
+}
+function recallAlternative(models, embeddings, queryVector, preference, topK) {
+	const targets = preference.targets ?? [];
+	const modelMap = new Map(models.map((profile) => [profile.model, profile]));
+	const refModels = models.filter((profile) => matchesAnyTarget(profile, targets));
+	const refFamilies = new Set(refModels.map((profile) => profile.family).filter(Boolean));
+	const results = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const profile of refModels) {
+		results.push({
+			model: profile,
+			score: 1
+		});
+		seen.add(profile.model);
+	}
+	const altPool = models.filter((profile) => !seen.has(profile.model) && (!profile.family || !refFamilies.has(profile.family)));
+	const scored = rankByEmbedding(embeddings, queryVector, new Set(altPool.map((profile) => profile.model)), topK - results.length);
+	for (const { id, similarity } of scored) {
+		const model = modelMap.get(id);
+		if (model) results.push({
+			model,
+			score: similarity
+		});
+	}
+	return results;
+}
+async function recallSemantic(config, models, query, topK, intent) {
+	let embeddings = getEmbeddings();
+	if (!embeddings) {
+		embeddings = await buildAndCacheEmbeddings(config, models);
+		cachedEmbeddings = embeddings;
+	}
+	const queryVector = await embedQuery(config, query);
+	const modelMap = new Map(models.map((profile) => [profile.model, profile]));
+	const preference = intent?.modelPreference;
+	const excludes = preference?.excludes ?? [];
+	if (preference && preference.mode !== "unconstrained") {
+		let results;
+		switch (preference.mode) {
+			case "scoped":
+				results = recallScoped(models, embeddings, queryVector, preference, topK);
+				break;
+			case "comparison":
+				results = recallComparison(models, embeddings, queryVector, preference, topK);
+				break;
+			case "alternative":
+				results = recallAlternative(models, embeddings, queryVector, preference, topK);
+				break;
+			default: results = [];
+		}
+		return applyExcludes(results, excludes);
+	}
+	if (intent?.complexity === Complexities.Pipeline && intent.segments?.length) {
+		const seen = /* @__PURE__ */ new Set();
+		const results = [];
+		const perSegment = Math.max(5, Math.ceil(topK / intent.segments.length));
+		for (const segment of intent.segments) {
+			const matched = models.filter((profile) => matchesSegment(profile, segment));
+			const allowedIds = new Set(matched.filter((profile) => !seen.has(profile.model)).map((profile) => profile.model));
+			if (allowedIds.size === 0) continue;
+			const scored = rankByEmbedding(embeddings, queryVector, allowedIds, perSegment);
+			for (const { id, similarity } of scored) {
+				const model = modelMap.get(id);
+				if (model && !seen.has(id)) {
+					results.push({
+						model,
+						score: similarity
+					});
+					seen.add(id);
+				}
+			}
+		}
+		return applyExcludes(results, excludes);
+	}
+	const allIds = new Set(models.map((profile) => profile.model));
+	const scored = rankByEmbedding(embeddings, queryVector, allIds, topK);
+	const results = [];
+	for (const { id, similarity } of scored) {
+		const model = modelMap.get(id);
+		if (model) results.push({
+			model,
+			score: similarity
+		});
+	}
+	return applyExcludes(results, excludes);
+}
+//#endregion
+//#region src/advisor/recommend.ts
+function formatPrices(profile) {
+	if (!profile.prices?.length) return void 0;
+	return profile.prices.map((price) => `${price.type}:${price.price}/${price.unit}`).join(", ");
+}
+function formatQpm(profile) {
+	if (!profile.qpmInfo) return void 0;
+	const entries = Object.entries(profile.qpmInfo);
+	if (entries.length === 0) return void 0;
+	return entries.map(([key, limit]) => `${key}:${limit.count_limit}/${limit.count_limit_period}s`).join(", ");
+}
+function buildCandidatesContext(candidates) {
+	return candidates.map(({ model: profile }) => {
+		const parts = [
+			`ID: ${profile.model}`,
+			`名称: ${profile.name}`,
+			`描述: ${profile.shortDescription || profile.description}`,
+			`能力: ${profile.capabilities.join(", ")}`,
+			`特性: ${profile.features.join(", ")}`
+		];
+		if (profile.contextWindow) parts.push(`上下文窗口: ${profile.contextWindow}`);
+		if (profile.maxOutputTokens) parts.push(`最大输出: ${profile.maxOutputTokens}`);
+		if (profile.category) parts.push(`类别: ${profile.category}`);
+		const modality = profile.inferenceMetadata;
+		if (modality?.request_modality?.length) parts.push(`输入模态: ${modality.request_modality.join(", ")}`);
+		if (modality?.response_modality?.length) parts.push(`输出模态: ${modality.response_modality.join(", ")}`);
+		const prices = formatPrices(profile);
+		if (prices) parts.push(`定价: ${prices}`);
+		const qpm = formatQpm(profile);
+		if (qpm) parts.push(`QPM: ${qpm}`);
+		if (profile.versionTag) parts.push(`版本: ${profile.versionTag}`);
+		if (profile.openSource !== void 0) parts.push(`开源: ${profile.openSource ? "是" : "否"}`);
+		if (profile.family) parts.push(`家族: ${profile.family}`);
+		return parts.join(" | ");
+	}).join("\n");
+}
+function buildIntentContext(intent) {
+	const { taskSummary, scenarioHints, inputModality, outputModality, requiredCapabilities, requiredFeatures, budget, qualityPreference, contextNeed, segments, modelPreference } = intent;
+	const parts = [];
+	if (taskSummary) parts.push(`场景理解: ${taskSummary}`);
+	if (scenarioHints.length) parts.push(`场景特征: ${scenarioHints.join(", ")}`);
+	if (inputModality.length) parts.push(`输入模态: ${inputModality.join(", ")}`);
+	if (outputModality.length) parts.push(`输出模态: ${outputModality.join(", ")}`);
+	if (requiredCapabilities.length) parts.push(`所需能力: ${requiredCapabilities.join(", ")}`);
+	if (requiredFeatures.length) parts.push(`所需特性: ${requiredFeatures.join(", ")}`);
+	parts.push(`预算倾向: ${budget}`);
+	parts.push(`质量偏好: ${qualityPreference}`);
+	if (contextNeed !== ContextNeeds.Standard) parts.push(`上下文需求: ${contextNeed}`);
+	if (modelPreference && modelPreference.mode !== "unconstrained") {
+		parts.push(`模型偏好: ${modelPreference.mode}`);
+		if (modelPreference.targets?.length) parts.push(`目标模型: ${modelPreference.targets.join(", ")}`);
+		if (modelPreference.excludes?.length) parts.push(`排除模型: ${modelPreference.excludes.join(", ")}`);
+	}
+	if (segments?.length) {
+		parts.push(`拆解步骤:`);
+		for (const seg of segments) {
+			const inMod = seg.inputModality.join(",") || "无";
+			const outMod = seg.outputModality.join(",") || "无";
+			const caps = seg.requiredCapabilities.join(",") || "无";
+			parts.push(`  - ${seg.step} (输入: ${inMod} → 输出: ${outMod}, 能力: ${caps})`);
+		}
+	}
+	return parts.join("\n");
+}
+function buildDocLink(docUrl) {
+	if (!docUrl) return void 0;
+	const match = docUrl.match(/\/(\d+)\.html/);
+	if (!match) return void 0;
+	return `https://bailian.console.aliyun.com/cn-beijing?tab=doc#/doc/?type=model&url=${match[1]}`;
+}
+function buildRecommendations(items, modelMap, limit) {
+	const list = Array.isArray(items) ? items : [];
+	const recommendations = [];
+	const seenFamilies = /* @__PURE__ */ new Set();
+	for (const item of list) {
+		const profile = modelMap.get(item.model);
+		if (!profile) continue;
+		if (profile.family && seenFamilies.has(profile.family)) continue;
+		if (profile.family) seenFamilies.add(profile.family);
+		const { model, name, category, contextWindow, maxOutputTokens, docUrl } = profile;
+		recommendations.push({
+			model,
+			name,
+			reason: item.reason ?? "",
+			highlights: item.highlights ?? [],
+			category,
+			contextWindow,
+			maxOutputTokens,
+			docUrl
+		});
+		if (recommendations.length >= limit) break;
+	}
+	return recommendations;
+}
+function validatePipelineCompatibility(steps, modelMap) {
+	for (let stepIdx = 1; stepIdx < steps.length; stepIdx++) {
+		const prevStep = steps[stepIdx - 1];
+		const currStep = steps[stepIdx];
+		const prevOutputs = new Set(prevStep.recommendations.flatMap((rec) => {
+			return modelMap.get(rec.model)?.inferenceMetadata?.response_modality ?? [];
+		}));
+		if (prevOutputs.size === 0) continue;
+		const warnings = [];
+		for (const rec of currStep.recommendations) {
+			const accepts = modelMap.get(rec.model)?.inferenceMetadata?.request_modality ?? [];
+			if (!accepts.some((mod) => prevOutputs.has(mod)) && accepts.length > 0) warnings.push(`${rec.name} 的输入模态 [${accepts.join(", ")}] 可能不兼容上一步的输出模态 [${[...prevOutputs].join(", ")}]`);
+		}
+		if (warnings.length > 0) currStep.warnings = warnings;
+	}
+}
+async function rankModels(config, candidates, intent, userInput, top, options) {
+	const candidatesContext = buildCandidatesContext(candidates);
+	const intentContext = buildIntentContext(intent);
+	const preferenceMode = intent.modelPreference?.mode;
+	let systemPrompt;
+	if (preferenceMode === "comparison") systemPrompt = COMPARISON_SYSTEM_PROMPT;
+	else if (preferenceMode === "alternative") systemPrompt = ALTERNATIVE_SYSTEM_PROMPT;
+	else if (preferenceMode === "scoped") {
+		const scopeNote = intent.modelPreference?.targets?.length ? `\n\n## 范围限定\n用户明确要求在以下范围内推荐：${intent.modelPreference.targets.join("、")}。请优先从匹配该范围的模型中选择。` : "";
+		systemPrompt = (intent.complexity === Complexities.Pipeline ? PIPELINE_SYSTEM_PROMPT : SINGLE_SYSTEM_PROMPT) + scopeNote;
+	} else systemPrompt = intent.complexity === Complexities.Pipeline ? PIPELINE_SYSTEM_PROMPT : SINGLE_SYSTEM_PROMPT;
+	const useThinkingModel = options?.enableThinking ?? false;
+	const userMessage = intent.complexity === Complexities.Pipeline ? `意图分析结果：\n${intentContext}\n\n候选模型列表：\n${candidatesContext}\n\n用户原始需求：${userInput}\n\n请为流水线各步骤各推荐最多 ${top} 个模型。` : `意图分析结果：\n${intentContext}\n\n候选模型列表：\n${candidatesContext}\n\n用户原始需求：${userInput}\n\n请推荐最多 ${top} 个模型。`;
+	const body = {
+		model: useThinkingModel ? RANKING_MODEL : RANKING_MODEL_FAST,
+		messages: [{
+			role: "system",
+			content: systemPrompt
+		}, {
+			role: "user",
+			content: userMessage
+		}],
+		max_tokens: 4096,
+		temperature: 0
+	};
+	if (useThinkingModel) {
+		body.stream = true;
+		body.enable_thinking = true;
+	}
+	const url = chatEndpoint(config.baseUrl);
+	let content;
+	if (useThinkingModel) {
+		const res = await request(config, {
+			url,
+			method: "POST",
+			body,
+			stream: true
+		});
+		let accumulated = "";
+		let contentStarted = false;
+		for await (const event of parseSSE(res)) {
+			if (event.data === "[DONE]") break;
+			try {
+				const parsed = JSON.parse(event.data);
+				for (const choice of parsed.choices) {
+					const delta = choice.delta;
+					if (delta.reasoning_content && options?.onThinking) options.onThinking(delta.reasoning_content);
+					if (delta.content) {
+						if (!contentStarted) {
+							contentStarted = true;
+							options?.onContentStart?.();
+						}
+						accumulated += delta.content;
+					}
+				}
+			} catch {}
+		}
+		content = accumulated || "{}";
+	} else content = (await requestJson(config, {
+		url,
+		method: "POST",
+		body
+	})).choices?.[0]?.message?.content ?? "{}";
+	let parsed;
+	try {
+		const jsonMatch = content.match(/\{[\s\S]*\}/);
+		parsed = JSON.parse(jsonMatch?.[0] ?? "{}");
+	} catch {
+		return {
+			type: Complexities.Single,
+			recommendations: []
+		};
+	}
+	const modelMap = new Map(candidates.map(({ model: profile }) => [profile.model, profile]));
+	if (parsed.type === Complexities.Pipeline && Array.isArray(parsed.steps)) {
+		const steps = [];
+		for (const rawStep of parsed.steps) {
+			const recs = buildRecommendations(rawStep.recommendations ?? (rawStep.model ? [rawStep] : []), modelMap, top);
+			if (recs.length > 0) steps.push({
+				step: rawStep.step ?? "",
+				recommendations: recs
+			});
+		}
+		validatePipelineCompatibility(steps, modelMap);
+		return {
+			type: Complexities.Pipeline,
+			summary: parsed.summary ?? "",
+			steps
+		};
+	}
+	const recommendations = buildRecommendations(parsed.recommendations ?? parsed ?? [], modelMap, top);
+	return {
+		type: Complexities.Single,
+		recommendations
+	};
+}
+//#endregion
+export { BAILIAN_HOST, BailianError, Budgets, CHANNEL, CONSOLE_GATEWAY_NO_TOKEN_MESSAGE, Capabilities, Complexities, ContextNeeds, DOCS_HOSTS, ExitCode, Features, GLOBAL_OPTIONS, McpClient, Modalities, ModelCategories, QualityPreferences, REGIONS, SOURCE_CONFIG, TAGS, analyzeIntent, appCompletionEndpoint, bailianMcpUrl, buildDocLink, callConsoleGateway, chatEndpoint, clearApiKey, createTrackingEvent, defineCommand, detectOutputFormat, ensureConfigDir, fetchModelList, flushTelemetry, formatErrorJson, formatJson, formatOutput, formatText, generateFilename, generateToolSchema, getConfigDir, getConfigPath, getCredentialsPath, getModels, imageEndpoint, imageSyncEndpoint, isCI, isInteractive, isLocalFile, isSemanticAvailable, loadApiKeyFromConfig, loadConfig, localSink, mapApiError, maskToken, mcpWebSearchEndpoint, memoryAddEndpoint, memoryListEndpoint, memoryNodeEndpoint, memorySearchEndpoint, parseBooleanValue, parseConfigFile, parseOptionalBooleanValue, parseSSE, profileSchemaEndpoint, rankModels, readConfigFile, recallCandidates, recallSemantic, remoteSink, request, requestJson, resolveBooleanFlag, resolveConsoleGatewayCredential, resolveCredential, resolveFileUrl, resolveOutputDir, resolveWatermark, saveApiKeyToConfig, signRequest, speechRecognizeEndpoint, speechSynthesizeEndpoint, stripUndefined, taskEndpoint, trackCommandExecution, trackingHeaders, uploadFile, userProfileEndpoint, videoGenerateEndpoint, writeConfigFile };