@klarkxy/dsh-ai-services 0.1.0

package/lib/index.js

@@ -0,0 +1,1299 @@
+import { AI_RPC_CHANNEL, CHAT_EVENTS_SLOT, MODEL_SETTINGS_SLOT, producerMessageSource } from "./contracts.js";
+import { registerHostRpc } from "./host-rpc.js";
+import { createInsertCollector } from "./insert-output.js";
+import { BlockAssembler, LlmError, ReasoningEffortId, createUserMessage, isAgentLoopRequest } from "@deepseek-ai/dsh-llm";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+//#region src/errors.ts
+var AiServicesError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "AiServicesError";
+	}
+};
+const AI_UNKNOWN_PURPOSE = "AI_UNKNOWN_PURPOSE";
+const AI_UNKNOWN_ROLE = "AI_UNKNOWN_ROLE";
+const AI_ROLE_UNSET = "AI_ROLE_UNSET";
+const AI_INVALID_ROUTE = "AI_INVALID_ROUTE";
+const AI_SESSION_UNAVAILABLE = "AI_SESSION_UNAVAILABLE";
+const AI_SESSION_INVALID = "AI_SESSION_INVALID";
+const AI_POLICY_CONFLICT = "AI_POLICY_CONFLICT";
+const AI_POLICY_INVALID = "AI_POLICY_INVALID";
+const AI_POLICY_SAVE_FAILED = "AI_POLICY_SAVE_FAILED";
+const AI_DUPLICATE_PURPOSE = "AI_DUPLICATE_PURPOSE";
+const AI_INACTIVE = "AI_INACTIVE";
+function fail$1(code, message) {
+	throw new AiServicesError(message, code);
+}
+function isAbortError(error) {
+	if (!error || typeof error !== "object") return false;
+	const name = "name" in error ? String(error.name) : "";
+	const code = "code" in error ? String(error.code) : "";
+	return name === "AbortError" || name === "TimeoutError" || code === "ABORT_ERR" || code === "ABORTED";
+}
+async function abortable(work, signal) {
+	signal.throwIfAborted();
+	let off = () => {};
+	const aborted = new Promise((_, reject) => {
+		const onAbort = () => reject(signal.reason instanceof Error ? signal.reason : Object.assign(/* @__PURE__ */ new Error("This operation was aborted"), { name: "AbortError" }));
+		signal.addEventListener("abort", onAbort, { once: true });
+		off = () => signal.removeEventListener("abort", onAbort);
+	});
+	try {
+		return await Promise.race([Promise.resolve().then(work), aborted]);
+	} finally {
+		off();
+	}
+}
+function publicCallError(code) {
+	if (code === "NO_ADAPTER") return "指定的模型供应不可用，未改用其他模型。";
+	if (code === "UNSUPPORTED_REASONING_EFFORT") return "该模型不支持所选推理强度，未改用其他设置。";
+	if (code === "INVALID_CREDENTIAL" || code === "AUTH" || code === "MISSING_CREDENTIAL") return "模型凭据不可用。";
+	if (code === "QUOTA") return "模型额度不足。";
+	if (code === "CONTEXT_WINDOW_EXCEEDED") return "输入超出模型上下文。";
+	return "模型调用失败。";
+}
+//#endregion
+//#region src/storage.ts
+const POLICY_KEY = "current";
+const DEFAULT_LIMITS = {
+	concurrency: 1,
+	timeoutMs: 6e4,
+	maxInputChars: 32e3,
+	maxOutputTokens: 2048,
+	maxAttempts: 2
+};
+const roleSchema = z.enum([
+	"normal",
+	"weak",
+	"strong",
+	"fantasy"
+]);
+const modelRouteSchema = z.object({
+	provider: z.string().trim().min(1).max(128),
+	model: z.string().trim().min(1).max(256),
+	reasoningEffort: z.string().trim().min(1).max(64).optional()
+}).strict();
+const modelTargetSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("role"),
+		role: roleSchema
+	}).strict(),
+	z.object({ kind: z.literal("session") }).strict(),
+	z.object({ kind: z.literal("model") }).merge(modelRouteSchema).strict()
+]);
+const limitsSchema = z.object({
+	concurrency: z.number().int().min(1).max(8),
+	timeoutMs: z.number().int().min(1e3).max(3e5),
+	maxInputChars: z.number().int().min(1).max(2e5),
+	maxOutputTokens: z.number().int().min(1).max(8192),
+	maxAttempts: z.number().int().min(1).max(5)
+}).strict();
+const policyDataSchema = z.object({
+	roles: z.object({
+		normal: modelRouteSchema.optional(),
+		weak: modelRouteSchema.optional(),
+		strong: modelRouteSchema.optional(),
+		fantasy: modelRouteSchema.optional()
+	}).strict(),
+	purposes: z.record(z.string().min(1).max(80), modelTargetSchema).refine((value) => Object.keys(value).length <= 200),
+	limits: limitsSchema
+}).strict();
+const storedPolicySchema = policyDataSchema.extend({ revision: z.number().int().nonnegative() }).strict().extend({ imports: z.array(z.string().min(1).max(80)).max(100).optional() }).strict();
+const updatePolicySchema = z.object({
+	expectedRevision: z.number().int().nonnegative(),
+	policy: policyDataSchema
+}).strict();
+const resolveRpcSchema = z.object({
+	purpose: z.string().min(1).max(80),
+	sessionId: z.string().min(1).max(128).optional(),
+	override: modelTargetSchema.optional()
+}).strict();
+const usageReceiptSchema = z.object({
+	id: z.string().min(1).max(80),
+	plugin: z.string().min(1).max(80),
+	purpose: z.string().min(1).max(80),
+	sessionId: z.string().max(128).optional(),
+	sourceVersion: z.string().max(128),
+	contractVersion: z.number().int().optional(),
+	promptVersion: z.string().max(80).optional(),
+	schemaVersion: z.string().max(80).optional(),
+	route: z.object({
+		provider: z.string(),
+		model: z.string(),
+		reasoningEffort: z.string().optional(),
+		source: z.enum([
+			"override",
+			"purpose",
+			"default"
+		]),
+		target: modelTargetSchema,
+		policyRevision: z.number().int().nonnegative(),
+		inheritedRole: roleSchema.optional()
+	}).strict().optional(),
+	status: z.enum([
+		"success",
+		"failed",
+		"cancelled",
+		"superseded",
+		"skipped"
+	]),
+	attempts: z.number().int().nonnegative(),
+	inputTokens: z.number().int().nonnegative().optional(),
+	outputTokens: z.number().int().nonnegative().optional(),
+	cost: z.null(),
+	startedAt: z.number(),
+	finishedAt: z.number(),
+	error: z.string().max(240).optional()
+}).strict();
+const storedReceiptsSchema = z.object({ items: z.array(usageReceiptSchema).max(100) }).strict();
+const purposeSpecSchema = z.object({
+	id: z.string().regex(/^[A-Za-z][A-Za-z0-9._:-]{0,79}$/),
+	label: z.string().trim().min(1).max(80),
+	defaultTarget: modelTargetSchema,
+	maxOutputTokens: z.number().int().min(1).max(8192).optional(),
+	maxInputChars: z.number().int().min(1).max(2e5).optional(),
+	timeoutMs: z.number().int().min(1e3).max(3e5).optional()
+}).strict();
+function defaultPolicy() {
+	return {
+		revision: 0,
+		roles: {},
+		purposes: {},
+		limits: { ...DEFAULT_LIMITS }
+	};
+}
+function clonePolicy(policy) {
+	return structuredClone(policy);
+}
+function parsePolicyData(value) {
+	const parsed = policyDataSchema.safeParse(value);
+	if (!parsed.success) fail$1(AI_POLICY_INVALID, "模型策略格式无效。");
+	return parsed.data;
+}
+function sanitizeReceipt(receipt) {
+	return usageReceiptSchema.parse({
+		...receipt,
+		cost: null,
+		error: receipt.error?.slice(0, 240)
+	});
+}
+function boundedReceipts(items) {
+	return storedReceiptsSchema.parse({ items: items.map(sanitizeReceipt).slice(-100) }).items;
+}
+const aiServicesDomain = defineDomain({
+	name: "dsh_editor_ai_services",
+	version: 1,
+	tables: {
+		policy: domainTable(storedPolicySchema),
+		receipts: domainTable(storedReceiptsSchema)
+	}
+});
+function isModelRole(value) {
+	return value === "normal" || value === "weak" || value === "strong" || value === "fantasy";
+}
+function cloneRoute(route) {
+	return route.reasoningEffort ? {
+		provider: route.provider,
+		model: route.model,
+		reasoningEffort: route.reasoningEffort
+	} : {
+		provider: route.provider,
+		model: route.model
+	};
+}
+function clonePurpose(spec) {
+	return structuredClone(spec);
+}
+//#endregion
+//#region src/rpc.ts
+function fail(code, message) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message
+		}
+	};
+}
+function mapError(error) {
+	if (error instanceof AiServicesError) return fail(error.code, error.message);
+	return fail("AI_REQUEST_FAILED", "操作失败，请刷新后重试。");
+}
+async function handleAiRpc(service, endpoint, payload, signal) {
+	try {
+		signal.throwIfAborted();
+		if (endpoint === "status") {
+			if (payload !== void 0 && payload !== null && (typeof payload !== "object" || Array.isArray(payload) || Object.keys(payload).length > 0)) return fail("AI_INVALID_REQUEST", "未知操作。");
+			return {
+				ok: true,
+				value: {
+					policy: service.getPolicy(),
+					purposes: service.purposes(),
+					storageFailed: Boolean(service.storageFailedFlag)
+				}
+			};
+		}
+		if (endpoint === "update") {
+			const parsed = updatePolicySchema.safeParse(payload);
+			if (!parsed.success) return fail("AI_INVALID_REQUEST", "策略格式无效。");
+			return {
+				ok: true,
+				value: await service.updatePolicy(parsed.data.policy, parsed.data.expectedRevision)
+			};
+		}
+		if (endpoint === "resolve") {
+			const parsed = resolveRpcSchema.safeParse(payload);
+			if (!parsed.success) return fail("AI_INVALID_REQUEST", "路由请求无效。");
+			return {
+				ok: true,
+				value: await service.resolve(parsed.data.purpose, parsed.data.sessionId, parsed.data.override)
+			};
+		}
+		if (endpoint === "usage") {
+			if (payload !== void 0 && payload !== null && (typeof payload !== "object" || Array.isArray(payload) || Object.keys(payload).length > 0)) return fail("AI_INVALID_REQUEST", "未知操作。");
+			return {
+				ok: true,
+				value: service.usage()
+			};
+		}
+		return fail("AI_INVALID_REQUEST", "未知操作。");
+	} catch (error) {
+		if (signal.aborted) return fail("AI_CANCELLED", "请求已取消。");
+		return mapError(error);
+	}
+}
+//#endregion
+//#region src/generate.ts
+const PERMANENT_CODES = /* @__PURE__ */ new Set([
+	"NO_ADAPTER",
+	"UNSUPPORTED_REASONING_EFFORT",
+	"INVALID_PREPARED_CALL",
+	"INVALID_CREDENTIAL",
+	"AUTH",
+	"MISSING_CREDENTIAL",
+	"QUOTA",
+	"CONTEXT_WINDOW_EXCEEDED"
+]);
+function joinText(assembler) {
+	return assembler.blocks().filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+async function consume(stream, signal, live, insert) {
+	const assembler = new BlockAssembler();
+	let sawFinish = false;
+	const collector = insert ? createInsertCollector(insert.maxChars) : void 0;
+	let boundedText;
+	const iterator = stream[Symbol.asyncIterator]();
+	try {
+		while (live()) {
+			const item = await abortable(() => iterator.next(), signal);
+			if (item.done) break;
+			if (item.value.type === "finish") sawFinish = true;
+			assembler.push(item.value);
+			if (collector && item.value.type === "text-delta") {
+				collector.append(item.value.text);
+				if (collector.full && !sawFinish && !assembler.blocks().some((block) => block.type === "tool-call")) {
+					boundedText = collector.text();
+					insert.stop();
+					break;
+				}
+			}
+		}
+	} finally {
+		try {
+			const closing = iterator.return?.();
+			if (closing) closing.catch(() => {});
+		} catch {}
+	}
+	return {
+		assembler,
+		sawFinish,
+		boundedText,
+		visibleText: collector?.text()
+	};
+}
+function outcomeFromAssembler(assembler, signal, sawFinish) {
+	if (signal.aborted) return {
+		text: "",
+		status: "cancelled",
+		error: "调用已取消。"
+	};
+	const finish = assembler.finish;
+	const usage = assembler.usage;
+	const tokens = usage ? {
+		inputTokens: usage.inputTokens,
+		outputTokens: usage.outputTokens
+	} : {};
+	if (finish.kind === "aborted") return {
+		text: "",
+		status: "cancelled",
+		error: "调用已取消。",
+		...tokens
+	};
+	if (finish.kind === "error") return {
+		text: "",
+		status: "failed",
+		error: publicCallError(finish.failure.code),
+		...tokens
+	};
+	if (!sawFinish) return {
+		text: "",
+		status: "failed",
+		error: "模型调用未完成。",
+		...tokens
+	};
+	if (finish.kind === "max-tokens") return {
+		text: "",
+		status: "failed",
+		error: "输出被截断。",
+		...tokens
+	};
+	if (finish.kind === "tool-calls" || assembler.blocks().some((block) => block.type === "tool-call")) return {
+		text: "",
+		status: "failed",
+		error: "辅助调用不使用工具。",
+		...tokens
+	};
+	if (finish.kind !== "stop") return {
+		text: "",
+		status: "failed",
+		error: "模型调用失败。",
+		...tokens
+	};
+	return {
+		text: joinText(assembler),
+		status: "success",
+		...tokens
+	};
+}
+async function generateAuxiliary(input) {
+	const { llm, plugin, route, system, text, maxTokens, maxAttempts, signal, sessionId, live } = input;
+	let last = {
+		text: "",
+		attempts: 0,
+		status: "failed",
+		error: "模型调用失败。"
+	};
+	const boundAttempts = Math.max(1, Math.min(5, maxAttempts));
+	for (let attempt = 1; attempt <= boundAttempts; attempt += 1) {
+		if (signal.aborted) return {
+			text: "",
+			attempts: attempt - 1,
+			status: "cancelled",
+			error: "调用已取消。"
+		};
+		if (!live()) return {
+			...last,
+			attempts: attempt - 1
+		};
+		try {
+			const effort = route.reasoningEffort ? ReasoningEffortId(route.reasoningEffort) : void 0;
+			const prepared = await llm.prepareCall({
+				provider: route.provider,
+				model: route.model,
+				...effort ? { reasoningEffort: effort } : {},
+				maxTokens
+			}, signal);
+			if (signal.aborted) return {
+				text: "",
+				attempts: attempt - 1,
+				status: "cancelled",
+				error: "调用已取消。"
+			};
+			if (!live()) return {
+				...last,
+				attempts: attempt - 1
+			};
+			const outputStop = new AbortController();
+			const outputSignal = AbortSignal.any([signal, outputStop.signal]);
+			const options = {
+				provider: prepared.config.provider,
+				model: prepared.config.model,
+				...prepared.config.reasoningEffort ? { reasoningEffort: prepared.config.reasoningEffort } : {},
+				...prepared.config.maxTokens !== void 0 ? { maxTokens: Math.min(maxTokens, prepared.config.maxTokens) } : { maxTokens },
+				...prepared.config.temperature !== void 0 ? { temperature: prepared.config.temperature } : {},
+				...prepared.config.stop ? { stop: [...prepared.config.stop] } : {},
+				system,
+				messages: [createUserMessage({
+					source: producerMessageSource(plugin),
+					content: [{
+						type: "text",
+						text
+					}]
+				})],
+				signal: outputSignal,
+				...sessionId ? { sessionId } : {}
+			};
+			const { assembler, sawFinish, boundedText, visibleText } = await consume(prepared.stream(options), signal, live, input.insert ? {
+				...input.insert,
+				stop: () => outputStop.abort()
+			} : void 0);
+			if (boundedText !== void 0 && !signal.aborted && live()) return {
+				text: boundedText,
+				status: "success",
+				attempts: attempt,
+				...assembler.usage ? {
+					inputTokens: assembler.usage.inputTokens,
+					outputTokens: assembler.usage.outputTokens
+				} : {}
+			};
+			last = {
+				...outcomeFromAssembler(assembler, signal, sawFinish),
+				attempts: attempt
+			};
+			if (last.status === "success" && visibleText !== void 0) last.text = visibleText;
+			if (last.status !== "failed") return last;
+			if (assembler.finish.kind !== "error") return last;
+			const code = assembler.finish.failure.code;
+			if (PERMANENT_CODES.has(code)) return last;
+		} catch (error) {
+			if (signal.aborted || isAbortError(error)) return {
+				text: "",
+				attempts: attempt,
+				status: "cancelled",
+				error: "调用已取消。"
+			};
+			if (error instanceof LlmError) {
+				last = {
+					text: "",
+					attempts: attempt,
+					status: "failed",
+					error: publicCallError(error.code)
+				};
+				if (PERMANENT_CODES.has(error.code)) return last;
+			} else last = {
+				text: "",
+				attempts: attempt,
+				status: "failed",
+				error: "模型调用失败。"
+			};
+		}
+	}
+	return last;
+}
+//#endregion
+//#region src/queue.ts
+function abortError(signal) {
+	if (signal.reason instanceof Error) return signal.reason;
+	return Object.assign(/* @__PURE__ */ new Error("This operation was aborted"), { name: "AbortError" });
+}
+/** Per-provider limiter: interactive waiters before background; background yields to in-flight agent streams. */
+var ProviderQueue = class {
+	limit;
+	running = 0;
+	agent = 0;
+	waiters = [];
+	constructor(limit) {
+		this.limit = limit;
+	}
+	noteAgent(delta) {
+		if (delta !== 0) this.agent = Math.max(0, this.agent + delta);
+		this.pump();
+	}
+	wake() {
+		this.pump();
+	}
+	get agentCount() {
+		return this.agent;
+	}
+	get runningCount() {
+		return this.running;
+	}
+	get waiterCount() {
+		return this.waiters.length;
+	}
+	async acquire(priority, signal) {
+		signal.throwIfAborted();
+		if (this.tryAcquire(priority)) return () => this.release();
+		await new Promise((resolve, reject) => {
+			let waiter;
+			const onAbort = () => {
+				const index = this.waiters.indexOf(waiter);
+				if (index < 0) return;
+				this.waiters.splice(index, 1);
+				waiter.dispose();
+				reject(abortError(signal));
+			};
+			waiter = {
+				priority,
+				signal,
+				resume: resolve,
+				reject,
+				dispose: () => signal.removeEventListener("abort", onAbort)
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+			this.enqueue(waiter);
+			this.pump();
+		});
+		return () => this.release();
+	}
+	enqueue(waiter) {
+		if (waiter.priority === "interactive") {
+			const index = this.waiters.findIndex((item) => item.priority === "background");
+			this.waiters.splice(index === -1 ? this.waiters.length : index, 0, waiter);
+			return;
+		}
+		this.waiters.push(waiter);
+	}
+	canStart(priority) {
+		if (this.running >= this.limit()) return false;
+		if (priority === "background" && this.agent > 0) return false;
+		return true;
+	}
+	tryAcquire(priority) {
+		if (!this.canStart(priority)) return false;
+		this.running += 1;
+		return true;
+	}
+	release() {
+		this.running = Math.max(0, this.running - 1);
+		this.pump();
+	}
+	pump() {
+		while (true) {
+			const index = this.waiters.findIndex((waiter) => this.canStart(waiter.priority));
+			if (index < 0) return;
+			const waiter = this.waiters[index];
+			if (!this.tryAcquire(waiter.priority)) return;
+			this.waiters.splice(index, 1);
+			waiter.dispose();
+			waiter.resume();
+		}
+	}
+};
+var ProviderQueues = class {
+	limit;
+	queues = /* @__PURE__ */ new Map();
+	constructor(limit) {
+		this.limit = limit;
+	}
+	forProvider(provider) {
+		let queue = this.queues.get(provider);
+		if (!queue) {
+			queue = new ProviderQueue(this.limit);
+			this.queues.set(provider, queue);
+		}
+		return queue;
+	}
+	noteAgent(provider, delta) {
+		this.forProvider(provider).noteAgent(delta);
+	}
+	wake() {
+		for (const queue of this.queues.values()) queue.wake();
+	}
+};
+//#endregion
+//#region src/routing.ts
+function streamReasoningEffort(value) {
+	if (typeof value !== "string") return void 0;
+	const id = value.trim();
+	if (!id) return void 0;
+	return id;
+}
+function asCallConfig(route) {
+	const effort = streamReasoningEffort(route.reasoningEffort);
+	return effort ? {
+		provider: route.provider,
+		model: route.model,
+		reasoningEffort: ReasoningEffortId(effort)
+	} : {
+		provider: route.provider,
+		model: route.model
+	};
+}
+async function validateRoute(llm, route, signal) {
+	if (!route.provider.trim() || !route.model.trim()) fail$1(AI_INVALID_ROUTE, "指定的模型路由不完整，未改用其他模型。");
+	try {
+		const work = () => llm.resolveCallConfig(asCallConfig(route), signal);
+		await (signal ? abortable(work, signal) : work());
+	} catch (error) {
+		if (signal?.aborted || isAbortError(error)) throw error;
+		if (error instanceof LlmError) fail$1(AI_INVALID_ROUTE, publicCallError(error.code));
+		fail$1(AI_INVALID_ROUTE, "指定的模型路由无效，未改用其他模型。");
+	}
+}
+function configuredRole(policy, role) {
+	const route = policy.roles[role];
+	if (!route) return void 0;
+	if (!route.provider.trim() || !route.model.trim()) return void 0;
+	return cloneRoute(route);
+}
+async function resolveTarget(input) {
+	const { llm, policy, target, source, sessionId, sessionModels, defaultModel, modelCenterAvailable, signal } = input;
+	const policyRevision = policy.revision;
+	if (target.kind === "model") {
+		const route = cloneRoute({
+			provider: target.provider,
+			model: target.model,
+			...streamReasoningEffort(target.reasoningEffort) ? { reasoningEffort: streamReasoningEffort(target.reasoningEffort) } : {}
+		});
+		await validateRoute(llm, route, signal);
+		return {
+			...route,
+			source,
+			target,
+			policyRevision
+		};
+	}
+	if (target.kind === "session") {
+		if (!sessionId) fail$1(AI_SESSION_UNAVAILABLE, "会话模型需要当前会话。");
+		if (!sessionModels) fail$1(AI_SESSION_UNAVAILABLE, "无法读取当前会话模型。");
+		let selected;
+		try {
+			selected = await sessionModels(sessionId, signal);
+		} catch (error) {
+			if (signal?.aborted || isAbortError(error)) throw error;
+			if (error instanceof AiServicesError) throw error;
+			if (error instanceof Error && error.message) fail$1(AI_SESSION_INVALID, error.message);
+			fail$1(AI_SESSION_UNAVAILABLE, "无法读取当前会话模型。");
+		}
+		const effort = streamReasoningEffort(selected.reasoningEffort);
+		const route = effort ? {
+			provider: selected.provider,
+			model: selected.model,
+			reasoningEffort: effort
+		} : {
+			provider: selected.provider,
+			model: selected.model
+		};
+		await validateRoute(llm, route, signal);
+		return {
+			...route,
+			source,
+			target,
+			policyRevision
+		};
+	}
+	if (!isModelRole(target.role)) fail$1(AI_UNKNOWN_ROLE, "未知模型角色。");
+	let inheritedRole;
+	let route = modelCenterAvailable === false ? void 0 : configuredRole(policy, target.role);
+	if (!route) {
+		route = configuredRole(policy, "normal") ?? defaultModel?.();
+		if (!route) fail$1(AI_ROLE_UNSET, "请先设置默认对话模型。");
+		route = cloneRoute(route);
+		if (target.role !== "normal") inheritedRole = "normal";
+	}
+	await validateRoute(llm, route, signal);
+	return inheritedRole ? {
+		...route,
+		source,
+		target,
+		policyRevision,
+		inheritedRole
+	} : {
+		...route,
+		source,
+		target,
+		policyRevision
+	};
+}
+async function resolvePurposeRoute(input) {
+	const { llm, policy, purpose, spec, sessionId, override, sessionModels, defaultModel, modelCenterAvailable, signal } = input;
+	if (override) return resolveTarget({
+		llm,
+		policy,
+		target: override,
+		source: "override",
+		sessionId,
+		sessionModels,
+		defaultModel,
+		modelCenterAvailable,
+		signal
+	});
+	const mapped = policy.purposes[purpose];
+	if (mapped) return resolveTarget({
+		llm,
+		policy,
+		target: mapped,
+		source: "purpose",
+		sessionId,
+		sessionModels,
+		defaultModel,
+		modelCenterAvailable,
+		signal
+	});
+	if (spec) return resolveTarget({
+		llm,
+		policy,
+		target: spec.defaultTarget,
+		source: "default",
+		sessionId,
+		sessionModels,
+		defaultModel,
+		modelCenterAvailable,
+		signal
+	});
+	fail$1(AI_UNKNOWN_PURPOSE, "用途未注册。");
+}
+function routeFromSelection(value, message) {
+	if (typeof value?.provider !== "string" || typeof value.model !== "string") fail$1(AI_SESSION_INVALID, message);
+	const effort = streamReasoningEffort(value.reasoningEffort);
+	return effort ? {
+		provider: value.provider,
+		model: value.model,
+		reasoningEffort: effort
+	} : {
+		provider: value.provider,
+		model: value.model
+	};
+}
+/**
+* Read the live host picker. A durable pending choice wins, then the route
+* recorded by the current request, then the host's default model.
+*/
+function sessionModelsFromHost(getHost) {
+	return async (sessionId, signal) => {
+		signal?.throwIfAborted();
+		const host = getHost();
+		if (!host?.agents || !host.sessionProjections) fail$1(AI_SESSION_UNAVAILABLE, "无法读取当前会话模型。");
+		const session = host.agents.get(sessionId)?.session;
+		if (!session) fail$1(AI_SESSION_UNAVAILABLE, "当前会话不在 Host 中，无法读取模型。");
+		let projection;
+		try {
+			projection = host.sessionProjections.stateOf(session, "modelSelection");
+		} catch (error) {
+			if (signal?.aborted || isAbortError(error)) throw error;
+			fail$1(AI_SESSION_UNAVAILABLE, "无法读取当前会话模型。");
+		}
+		signal?.throwIfAborted();
+		if (!projection) fail$1(AI_SESSION_UNAVAILABLE, "当前会话模型投影不可用。");
+		if (projection.pending !== null && projection.pending !== void 0) return routeFromSelection(projection.pending, "当前会话模型选择无效。");
+		const header = session.requestHeader?.();
+		const recorded = header?.config;
+		if (recorded !== void 0) return routeFromSelection(header?.adapterDefaults?.reasoningEffort === true ? {
+			provider: recorded.provider,
+			model: recorded.model
+		} : recorded, "当前会话模型记录无效。");
+		return routeFromSelection(host.agentDefaultModel?.currentSelection(), "默认对话模型不可用。");
+	};
+}
+//#endregion
+//#region src/service.ts
+const PLUGIN_NAME = /^(?:@[A-Za-z0-9._-]+\/)?[A-Za-z0-9._-]+$/;
+function pluginName(value) {
+	const id = value.trim();
+	if (!id || id.length > 80 || id.includes("..") || !PLUGIN_NAME.test(id)) fail$1(AI_POLICY_INVALID, "插件标识无效。");
+	return id;
+}
+function minLimit(policyValue, purposeValue) {
+	return purposeValue === void 0 ? policyValue : Math.min(policyValue, purposeValue);
+}
+var AiServicesRuntime = class {
+	options;
+	policy;
+	imports;
+	receipts;
+	storageFailed = false;
+	disposed = false;
+	pending = Promise.resolve();
+	purposeRegistry = /* @__PURE__ */ new Map();
+	lifetimes = /* @__PURE__ */ new Set();
+	queues;
+	now;
+	id;
+	constructor(options) {
+		this.options = options;
+		this.imports = [...options.initialImports ?? []];
+		this.policy = clonePolicy(options.initialPolicy ?? defaultPolicy());
+		this.receipts = boundedReceipts(options.initialReceipts ?? []);
+		this.now = options.now ?? Date.now;
+		this.id = options.id ?? (() => randomUUID());
+		this.queues = new ProviderQueues(() => this.policy.limits.concurrency);
+	}
+	get storageFailedFlag() {
+		return this.storageFailed;
+	}
+	noteAgent(provider, delta) {
+		this.queues.noteAgent(provider, delta);
+	}
+	getPolicy() {
+		return clonePolicy(this.policy);
+	}
+	purposes() {
+		return [...this.purposeRegistry.values()].map((item) => ({
+			...clonePurpose(item),
+			plugin: item.plugin
+		}));
+	}
+	usage() {
+		return this.receipts.map((item) => structuredClone(item));
+	}
+	importPurposes(migrationId, defaults, roles = {}) {
+		const task = this.pending.then(async () => {
+			this.assertOpen();
+			if (!/^[A-Za-z][A-Za-z0-9._:-]{0,79}$/.test(migrationId)) fail$1(AI_POLICY_INVALID, "迁移标识无效。");
+			if (this.imports.includes(migrationId)) return this.getPolicy();
+			if (this.imports.length >= 100) fail$1(AI_POLICY_INVALID, "迁移记录已满。");
+			const { revision: _revision, ...current } = this.policy;
+			const parsed = parsePolicyData({
+				...current,
+				roles: {
+					...roles,
+					...current.roles
+				},
+				purposes: {
+					...defaults,
+					...this.policy.purposes
+				}
+			});
+			const purposes = {
+				...parsed.purposes,
+				...this.policy.purposes
+			};
+			const next = {
+				...this.getPolicy(),
+				roles: parsed.roles,
+				purposes,
+				revision: this.policy.revision + 1
+			};
+			const imports = [...this.imports, migrationId];
+			try {
+				await this.options.store.savePolicy(next, imports);
+			} catch {
+				this.storageFailed = true;
+				fail$1(AI_POLICY_SAVE_FAILED, "旧模型配置迁移失败，已保留原设置。");
+			}
+			this.policy = next;
+			this.imports = imports;
+			this.storageFailed = false;
+			return this.getPolicy();
+		});
+		this.pending = task.then(() => {}, () => {});
+		return task;
+	}
+	updatePolicy(policy, expectedRevision) {
+		const task = this.pending.then(async () => {
+			if (this.disposed) fail$1(AI_INACTIVE, "AI 服务已停止。");
+			if (expectedRevision !== this.policy.revision) fail$1(AI_POLICY_CONFLICT, "策略已被其他页面修改，请刷新后重试。");
+			const parsed = parsePolicyData(policy);
+			const next = {
+				...clonePolicy({
+					revision: expectedRevision + 1,
+					...parsed
+				}),
+				revision: expectedRevision + 1
+			};
+			try {
+				await this.options.store.savePolicy(next, this.imports);
+			} catch {
+				this.storageFailed = true;
+				fail$1(AI_POLICY_SAVE_FAILED, "策略保存失败，已保留原设置。");
+			}
+			this.policy = next;
+			this.storageFailed = false;
+			this.queues.wake();
+			return clonePolicy(this.policy);
+		});
+		this.pending = task.then(() => {}, () => {});
+		return task;
+	}
+	async resolve(purpose, sessionId, override) {
+		this.assertOpen();
+		const spec = this.purposeRegistry.get(purpose);
+		return resolvePurposeRoute({
+			llm: this.options.llm,
+			policy: this.policy,
+			purpose,
+			spec,
+			sessionId,
+			override,
+			sessionModels: this.options.sessionModels,
+			defaultModel: this.options.defaultModel,
+			modelCenterAvailable: this.options.modelCenterAvailable?.()
+		});
+	}
+	activate(plugin) {
+		this.assertOpen();
+		const name = pluginName(plugin);
+		const lifetime = {
+			plugin: name,
+			controller: new AbortController(),
+			active: true,
+			purposes: /* @__PURE__ */ new Map()
+		};
+		this.lifetimes.add(lifetime);
+		return {
+			plugin: name,
+			get signal() {
+				return lifetime.controller.signal;
+			},
+			get active() {
+				return lifetime.active && !lifetime.controller.signal.aborted;
+			},
+			registerPurpose: (spec) => this.registerPurpose(lifetime, spec),
+			run: (request) => this.run(lifetime, request),
+			dispose: () => this.disposeLifetime(lifetime)
+		};
+	}
+	async dispose() {
+		this.disposed = true;
+		for (const lifetime of [...this.lifetimes]) this.disposeLifetime(lifetime);
+		await this.pending;
+	}
+	assertOpen() {
+		if (this.disposed) fail$1(AI_INACTIVE, "AI 服务已停止。");
+	}
+	registerPurpose(lifetime, spec) {
+		if (!lifetime.active) fail$1(AI_INACTIVE, "插件范围已停用。");
+		let parsed;
+		try {
+			parsed = purposeSpecSchema.parse(spec);
+		} catch {
+			fail$1(AI_POLICY_INVALID, "用途声明无效。");
+		}
+		const existing = this.purposeRegistry.get(parsed.id);
+		if (existing && existing.plugin !== lifetime.plugin) fail$1(AI_DUPLICATE_PURPOSE, "用途已被其他插件注册。");
+		const owned = {
+			...clonePurpose(parsed),
+			plugin: lifetime.plugin
+		};
+		lifetime.purposes.set(parsed.id, owned);
+		this.purposeRegistry.set(parsed.id, owned);
+		let removed = false;
+		return () => {
+			if (removed) return;
+			removed = true;
+			lifetime.purposes.delete(parsed.id);
+			this.refreshPurpose(parsed.id);
+		};
+	}
+	disposeLifetime(lifetime) {
+		if (!lifetime.active && !this.lifetimes.has(lifetime)) return;
+		lifetime.active = false;
+		if (!lifetime.controller.signal.aborted) lifetime.controller.abort();
+		const ids = [...lifetime.purposes.keys()];
+		lifetime.purposes.clear();
+		this.lifetimes.delete(lifetime);
+		for (const id of ids) this.refreshPurpose(id);
+	}
+	refreshPurpose(id) {
+		for (const other of this.lifetimes) {
+			const spec = other.purposes.get(id);
+			if (spec && other.active) {
+				this.purposeRegistry.set(id, {
+					...spec,
+					plugin: other.plugin
+				});
+				return;
+			}
+		}
+		this.purposeRegistry.delete(id);
+	}
+	live(lifetime, request) {
+		if (!lifetime.active || lifetime.controller.signal.aborted || request.signal?.aborted) return false;
+		try {
+			if (request.isCurrent && !request.isCurrent()) return false;
+		} catch {
+			return false;
+		}
+		return true;
+	}
+	classify(lifetime, request, queued) {
+		const aborted = lifetime.controller.signal.aborted || Boolean(request.signal?.aborted);
+		let current = true;
+		try {
+			current = !request.isCurrent || request.isCurrent();
+		} catch {
+			current = false;
+		}
+		if (aborted) return "cancelled";
+		if (!lifetime.active || !current) return queued ? "superseded" : "skipped";
+	}
+	async run(lifetime, request) {
+		const startedAt = this.now();
+		const base = {
+			id: this.id(),
+			plugin: lifetime.plugin,
+			purpose: request.purpose,
+			...request.sessionId ? { sessionId: request.sessionId } : {},
+			sourceVersion: request.sourceVersion,
+			...request.contractVersion !== void 0 ? { contractVersion: request.contractVersion } : {},
+			...request.promptVersion ? { promptVersion: request.promptVersion } : {},
+			...request.schemaVersion ? { schemaVersion: request.schemaVersion } : {},
+			cost: null,
+			startedAt
+		};
+		let queued = false;
+		let timeout;
+		const finish = async (receipt, text = "") => {
+			let sealed = sanitizeReceipt({
+				...receipt,
+				finishedAt: this.now(),
+				cost: null
+			});
+			await this.record(sealed);
+			const again = this.classify(lifetime, request, queued);
+			if (again && (sealed.status === "success" || text !== "")) {
+				const { error: _error, ...rest } = sealed;
+				const timedOut = Boolean(timeout?.aborted) && !request.signal?.aborted && !lifetime.controller.signal.aborted;
+				sealed = sanitizeReceipt({
+					...rest,
+					status: again,
+					finishedAt: this.now(),
+					cost: null,
+					...again === "cancelled" ? { error: timedOut ? "调用超时。" : "调用已取消。" } : {}
+				});
+				await this.record(sealed);
+				return {
+					text: "",
+					receipt: sealed
+				};
+			}
+			return {
+				text: sealed.status === "success" ? text : "",
+				receipt: sealed
+			};
+		};
+		const early = this.classify(lifetime, request, false);
+		if (early) return finish({
+			...base,
+			status: early,
+			attempts: 0,
+			finishedAt: this.now(),
+			...early === "cancelled" ? { error: "调用已取消。" } : {}
+		});
+		const spec = lifetime.purposes.get(request.purpose);
+		if (!spec) return finish({
+			...base,
+			status: "failed",
+			attempts: 0,
+			finishedAt: this.now(),
+			error: "用途未注册。"
+		});
+		if (request.insert && (!Number.isInteger(request.insert.maxChars) || request.insert.maxChars < 1 || request.insert.maxChars > 12e3)) return finish({
+			...base,
+			status: "failed",
+			attempts: 0,
+			finishedAt: this.now(),
+			error: "输出字符上限无效。"
+		});
+		const policy = this.policy;
+		const maxInputChars = minLimit(policy.limits.maxInputChars, spec.maxInputChars);
+		if (request.input.length + request.system.length > maxInputChars) return finish({
+			...base,
+			status: "failed",
+			attempts: 0,
+			finishedAt: this.now(),
+			error: "输入超出上限。"
+		});
+		const timeoutMs = minLimit(policy.limits.timeoutMs, spec.timeoutMs);
+		timeout = AbortSignal.timeout(timeoutMs);
+		const combined = AbortSignal.any([
+			lifetime.controller.signal,
+			timeout,
+			...request.signal ? [request.signal] : []
+		]);
+		let route;
+		try {
+			route = await abortable(() => resolvePurposeRoute({
+				llm: this.options.llm,
+				policy,
+				purpose: request.purpose,
+				spec,
+				sessionId: request.sessionId,
+				override: request.override,
+				sessionModels: this.options.sessionModels,
+				defaultModel: this.options.defaultModel,
+				modelCenterAvailable: this.options.modelCenterAvailable?.(),
+				signal: combined
+			}), combined);
+		} catch (error) {
+			const classified = this.classify(lifetime, request, false) ?? (isAbortError(error) || combined.aborted ? "cancelled" : void 0);
+			if (classified) {
+				const timedOut = timeout.aborted && !request.signal?.aborted && !lifetime.controller.signal.aborted;
+				return finish({
+					...base,
+					status: classified,
+					attempts: 0,
+					finishedAt: this.now(),
+					...classified === "cancelled" ? { error: timedOut ? "调用超时。" : "调用已取消。" } : {}
+				});
+			}
+			const message = error instanceof AiServicesError ? error.message : "模型路由无效，未改用其他模型。";
+			return finish({
+				...base,
+				status: "failed",
+				attempts: 0,
+				finishedAt: this.now(),
+				error: message
+			});
+		}
+		const afterResolve = this.classify(lifetime, request, false);
+		if (afterResolve) return finish({
+			...base,
+			status: afterResolve,
+			attempts: 0,
+			finishedAt: this.now(),
+			route,
+			...afterResolve === "cancelled" ? { error: "调用已取消。" } : {}
+		});
+		const maxOutputTokens = minLimit(policy.limits.maxOutputTokens, spec.maxOutputTokens);
+		const maxAttempts = policy.limits.maxAttempts;
+		const priority = request.priority === "interactive" ? "interactive" : "background";
+		queued = true;
+		let release = () => {};
+		try {
+			release = await this.queues.forProvider(route.provider).acquire(priority, combined);
+		} catch (error) {
+			const classified = this.classify(lifetime, request, true) ?? (isAbortError(error) || combined.aborted ? "cancelled" : "failed");
+			return finish({
+				...base,
+				status: classified,
+				attempts: 0,
+				finishedAt: this.now(),
+				route,
+				error: classified === "cancelled" ? timeout.aborted && !request.signal?.aborted && !lifetime.controller.signal.aborted ? "调用超时。" : "调用已取消。" : "排队失败。"
+			});
+		}
+		try {
+			const afterQueue = this.classify(lifetime, request, true);
+			if (afterQueue) return finish({
+				...base,
+				status: afterQueue,
+				attempts: 0,
+				finishedAt: this.now(),
+				route,
+				...afterQueue === "cancelled" ? { error: "调用已取消。" } : {}
+			});
+			const generated = await generateAuxiliary({
+				llm: this.options.llm,
+				plugin: lifetime.plugin,
+				route,
+				system: request.system,
+				text: request.input,
+				maxTokens: maxOutputTokens,
+				maxAttempts,
+				insert: request.insert,
+				signal: combined,
+				sessionId: request.sessionId,
+				live: () => this.live(lifetime, request)
+			});
+			const classified = this.classify(lifetime, request, true);
+			if (classified === "superseded") return finish({
+				...base,
+				status: "superseded",
+				attempts: generated.attempts,
+				finishedAt: this.now(),
+				route,
+				...generated.inputTokens !== void 0 ? { inputTokens: generated.inputTokens } : {},
+				...generated.outputTokens !== void 0 ? { outputTokens: generated.outputTokens } : {}
+			});
+			const timedOut = timeout.aborted && !request.signal?.aborted && !lifetime.controller.signal.aborted;
+			if (classified === "cancelled" || generated.status === "cancelled") return finish({
+				...base,
+				status: "cancelled",
+				attempts: generated.attempts,
+				finishedAt: this.now(),
+				route,
+				...generated.inputTokens !== void 0 ? { inputTokens: generated.inputTokens } : {},
+				...generated.outputTokens !== void 0 ? { outputTokens: generated.outputTokens } : {},
+				error: timedOut ? "调用超时。" : "调用已取消。"
+			});
+			if (generated.status !== "success") return finish({
+				...base,
+				status: generated.status,
+				attempts: generated.attempts,
+				finishedAt: this.now(),
+				route,
+				...generated.inputTokens !== void 0 ? { inputTokens: generated.inputTokens } : {},
+				...generated.outputTokens !== void 0 ? { outputTokens: generated.outputTokens } : {},
+				...generated.error ? { error: generated.error } : {}
+			});
+			return finish({
+				...base,
+				status: "success",
+				attempts: generated.attempts,
+				finishedAt: this.now(),
+				route,
+				...generated.inputTokens !== void 0 ? { inputTokens: generated.inputTokens } : {},
+				...generated.outputTokens !== void 0 ? { outputTokens: generated.outputTokens } : {}
+			}, generated.text);
+		} finally {
+			release();
+		}
+	}
+	record(receipt) {
+		const task = this.pending.then(async () => {
+			const index = this.receipts.findIndex((row) => row.id === receipt.id);
+			const list = [...this.receipts];
+			if (index >= 0) list[index] = receipt;
+			else list.push(receipt);
+			const next = boundedReceipts(list);
+			try {
+				await this.options.store.saveReceipts(next);
+				this.receipts = next;
+			} catch {
+				this.storageFailed = true;
+				this.receipts = next;
+			}
+		});
+		this.pending = task.then(() => {}, () => {});
+		return task;
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = "@klarkxy/dsh-ai-services";
+const inject = [
+	"llm",
+	"storageDomain",
+	"connection",
+	"webServer",
+	"agents",
+	"sessionProjections",
+	"agentDefaultModel"
+];
+function installForegroundPriority(ctx, service) {
+	return ctx.on.call(ctx, "llm/stream", (options, next) => {
+		if (!isAgentLoopRequest(options)) return next();
+		return (async function* () {
+			service.noteAgent(options.provider, 1);
+			try {
+				yield* next();
+			} finally {
+				service.noteAgent(options.provider, -1);
+			}
+		})();
+	}, {
+		global: true,
+		prepend: true
+	});
+}
+async function apply(ctx) {
+	const host = ctx;
+	const domain = await ctx.storageDomain.open(aiServicesDomain);
+	const policyTable = domain.table("policy");
+	const receiptTable = domain.table("receipts");
+	const stored = policyTable.get(POLICY_KEY);
+	const { imports = [], ...initialPolicy } = stored ?? {};
+	const service = new AiServicesRuntime({
+		llm: ctx.llm,
+		initialPolicy: stored ? initialPolicy : void 0,
+		initialImports: imports,
+		initialReceipts: receiptTable.get("log")?.items,
+		store: {
+			savePolicy: (policy, imports) => policyTable.put(POLICY_KEY, {
+				...policy,
+				imports
+			}),
+			saveReceipts: (items) => receiptTable.put("log", { items: boundedReceipts(items) })
+		},
+		sessionModels: sessionModelsFromHost(() => ctx),
+		defaultModel: () => ctx.get("agentDefaultModel")?.currentSelection(),
+		modelCenterAvailable: () => Boolean(ctx.get("modelCenter"))
+	});
+	ctx.effect(() => async () => {
+		await service.dispose();
+		await domain.close();
+	}, "ai-services.dispose");
+	ctx.effect(() => installForegroundPriority(ctx, service), "ai-services.foreground");
+	ctx.provide("aiServices", service);
+	ctx.effect(() => registerHostRpc(host, AI_RPC_CHANNEL, (endpoint, payload, signal) => handleAiRpc(service, endpoint, payload, signal)), "ai-services.rpc");
+}
+//#endregion
+export { AI_RPC_CHANNEL, AiServicesRuntime, CHAT_EVENTS_SLOT, MODEL_SETTINGS_SLOT, apply, inject, name, registerHostRpc };
+
+//# sourceMappingURL=index.js.map