@morlay/dsh-session-mode 0.0.8 → 0.0.9

package/dist/index.cjs

@@ -0,0 +1,635 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_catalog = require("./catalog-K5cESbqA.cjs");
+const require_shared = require("./shared-sy45ixVR.cjs");
+let _deepseek_ai_cordis = require("@deepseek-ai/cordis");
+let _deepseek_ai_dsh_llm = require("@deepseek-ai/dsh-llm");
+let zod = require("zod");
+let _deepseek_ai_schemastery = require("@deepseek-ai/schemastery");
+_deepseek_ai_schemastery = __toESM(_deepseek_ai_schemastery, 1);
+let _deepseek_ai_dsh_system_prompt = require("@deepseek-ai/dsh-system-prompt");
+//#region src/modes.ts
+function derivedSkills(mode) {
+	return (mode.allowTools.length === 0 || mode.allowTools.includes("skill")) && !mode.denyTools.includes("skill");
+}
+const localized = (text) => text;
+const personaSchema = _deepseek_ai_schemastery.default.object({
+	prefix: _deepseek_ai_schemastery.default.string().default(""),
+	suffix: _deepseek_ai_schemastery.default.string().default("")
+});
+const roleSchema = _deepseek_ai_schemastery.default.union([_deepseek_ai_schemastery.default.const("main"), _deepseek_ai_schemastery.default.const("subagent")]);
+const modelSchema = _deepseek_ai_schemastery.default.object({
+	provider: _deepseek_ai_schemastery.default.string().role("select", { source: "llm-providers" }).description(localized({
+		zh: "服务商 id（部署里注册的任意路由，不论哪个适配器插件注册的）。",
+		en: "Provider id (any route registered in this deployment, whichever adapter plugin supplies it)."
+	})),
+	model: _deepseek_ai_schemastery.default.string().role("select", { source: "llm-models" }).description(localized({
+		zh: "模型 id。",
+		en: "Model id."
+	})),
+	reasoningEffort: _deepseek_ai_schemastery.default.string().description(localized({
+		zh: "思考档位；默认跟服务商自己的默认。",
+		en: "Reasoning effort; the default is the provider's own."
+	}))
+});
+const modeSchema = _deepseek_ai_schemastery.default.object({
+	preset: _deepseek_ai_schemastery.default.string().hidden(),
+	presetsOnly: _deepseek_ai_schemastery.default.array(_deepseek_ai_schemastery.default.string()).role("select", { source: "agent-presets" }).default([]).description(localized({
+		zh: "这个模式只允许挂哪些 agent preset（它们的 id，官方或本部署自建的）：行清单由挂着的那份提供，几个模式可以共享同一份名单。留空表示**允许全部**——哪份 preset 都行，选这个模式也不动会话当前挂着的那份；有值时当前的已经在名单里就不动，否则换成名单里的第一个。模式自己的提示词、工具收口与开关照常生效。",
+		en: "Which agent presets this mode may ride on (their ids, shipped or deployment-owned): that preset supplies the row list, and several modes may share one list. Empty means **every preset is allowed** — selecting the mode then leaves the session's current preset alone; when set, the current one stays if it is listed, otherwise the session switches to the first entry. The mode's persona, tool narrowing, and switches apply either way."
+	})),
+	name: _deepseek_ai_schemastery.default.string().required().description(localized({
+		zh: "模式名（事实文案；选择面归官方 roster）。",
+		en: "Mode name (fact copy; the picker belongs to the official roster)."
+	})),
+	description: _deepseek_ai_schemastery.default.string().default("").description(localized({
+		zh: "一句话说明。",
+		en: "One-line description."
+	})),
+	role: _deepseek_ai_schemastery.default.array(roleSchema).default(["main"]).description(localized({
+		zh: "谁可以用这个模式：`main`（会话选择器里可选）或 `subagent`（子代理继承）。",
+		en: "Who may use this mode: `main` (selectable in sessions) or `subagent` (inherited by subagents)."
+	})),
+	persona: personaSchema.default({}),
+	allowTools: _deepseek_ai_schemastery.default.array(_deepseek_ai_schemastery.default.string()).role("select", { source: "catalog-tools" }).default([]).description(localized({
+		zh: "这个会话能用的工具；其余既不进目录，调用也被拒。**留空就是不设收窄**：用这个会话挂着的 preset 提供的全部工具。",
+		en: "Tools this session may use; everything else leaves the catalog and calls are refused. Leave it empty to narrow nothing: the session then uses every tool its preset provides."
+	})),
+	denyTools: _deepseek_ai_schemastery.default.array(_deepseek_ai_schemastery.default.string()).role("select", { source: "catalog-tools" }).default([]).description(localized({
+		zh: "这个模式不用的工具（黑名单）：从 `allowTools` 定下的那份里减掉（`allowTools` 留空就是从全部里减）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
+		en: "Tools this mode must not use (deny list): subtracted from whatever `allowTools` settled on (with an empty `allowTools`, from everything). Empty denies nothing; a name in both lists is denied."
+	})),
+	allowSkills: _deepseek_ai_schemastery.default.array(_deepseek_ai_schemastery.default.string()).role("select", { source: "catalog-skills" }).default([]).description(localized({
+		zh: "这个模式能用的技能；其余既不进技能目录，`skill` 工具加载它也被拒。**留空就是不设收窄**：技能注册表里有什么就用什么。",
+		en: "Skills this mode may use; everything else leaves the skill catalog and loading it through the `skill` tool is refused. Leave it empty to narrow nothing: the session then sees every skill the registry carries."
+	})),
+	denySkills: _deepseek_ai_schemastery.default.array(_deepseek_ai_schemastery.default.string()).role("select", { source: "catalog-skills" }).default([]).description(localized({
+		zh: "这个模式不用的技能（黑名单）：从 `allowSkills` 定下的那份里减掉（`allowSkills` 留空就是从全部里减）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
+		en: "Skills this mode must not use (deny list): subtracted from whatever `allowSkills` settled on (with an empty `allowSkills`, from everything). Empty denies nothing; a name in both lists is denied."
+	})),
+	allowPolicies: _deepseek_ai_schemastery.default.array(_deepseek_ai_schemastery.default.string()).role("select", { source: "policies" }).default([]).description(localized({
+		zh: "上游 policy 规则的生效白名单（`fs/write-intent` / `fs/edit-intent`）：留空 = 全部规则照旧生效；有值 = 只有列出的生效，其余的被绕过。",
+		en: "Allow list of upstream policy rules that stay in force (`fs/write-intent` / `fs/edit-intent`): empty keeps every rule; when set, only the listed ones stay, and the others are bypassed."
+	})),
+	denyPolicies: _deepseek_ai_schemastery.default.array(_deepseek_ai_schemastery.default.string()).role("select", { source: "policies" }).default([]).description(localized({
+		zh: "上游 policy 规则的黑名单：列出的规则禁用（它的裁决连拒绝一起丢掉，调用按没有这条规则继续）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
+		en: "Deny list of upstream policy rules: the listed ones are disabled — their verdict (rejection included) is dropped and the call proceeds as if the rule were absent. Empty denies nothing; a name in both lists is denied."
+	})),
+	instructions: _deepseek_ai_schemastery.default.boolean().default(true).description(localized({
+		zh: "是否要 instruction 类注入（工作区指令、用法正文）：`false` 时丢掉官方 `agent-instructions` 的注入，并关掉通道自己的降级注入。",
+		en: "Whether instruction-class injections apply (workspace instructions, guidance): `false` drops the official `agent-instructions` injection and turns off the channel's own demoted delivery."
+	})),
+	skills: _deepseek_ai_schemastery.default.boolean().description(localized({
+		zh: "是否要技能目录（官方 `skill-catalog` 的注入）。**默认就按这个模式自己的工具名单推导**：`(allowTools 留空 ? 全部 : allowTools) − denyTools` 里含 `skill` 就要；写 `false` 就丢掉官方 `skill-catalog` 的注入（`skill` 工具的可见性仍归 `allowTools`）。",
+		en: "Whether the skill catalog applies (the official `skill-catalog` injection). The default derives it from this mode's own tool lists: it applies when `(empty allowTools ? every tool : allowTools) − denyTools` contains `skill`; `false` drops the official `skill-catalog` injection (`skill` tool visibility still belongs to `allowTools`)."
+	})),
+	runtimeContext: _deepseek_ai_schemastery.default.boolean().default(true).description(localized({
+		zh: "是否要动态快照（文件沙箱策略、审批策略）与时钟注入（`standard` 那类 preset 声明的 `time-context`）。",
+		en: "Whether the runtime snapshot (sandbox and approval policy) and the clock injection (`time-context`, declared by presets such as `standard`) apply."
+	})),
+	defaultModel: modelSchema.default(null).description(localized({
+		zh: "这个模式的默认模型；不设就跟全局默认模型。只在会话还没有模型事实时接管。",
+		en: "Default model for this mode; empty follows the global default. Applies only while a session has no model fact yet."
+	}))
+});
+const Config = _deepseek_ai_schemastery.default.object({
+	default: _deepseek_ai_schemastery.default.string().required().description(localized({
+		zh: "新会话（还没选过模式的会话）用哪个模式；必须是下面 `modes` 里的一个 id。",
+		en: "Mode a session starts in before anyone picks one; must be an id in `modes`."
+	})).volatile(),
+	modes: _deepseek_ai_schemastery.default.dict(modeSchema).required().description(localized({
+		zh: "模式清单：id → 定义（persona / 工具名单 / 生效的 policy 规则 / 角色）。改它对**已运行会话**不自动生效——重挂后新建的会话、或重新应用模式的会话才用新定义。",
+		en: "Mode roster: id to definition (persona, tool lists, effective policy rules, role). Edits do not follow into already-running sessions; sessions created after the row is remounted use the new definition."
+	})).volatile(),
+	models: _deepseek_ai_schemastery.default.dict(modelSchema).default({}).hidden()
+});
+const POLICY_NAME_SET = new Set(require_shared.POLICY_NAMES);
+function configProblem(config) {
+	const roles = (id) => config.modes[id]?.role ?? ["main"];
+	const ids = Object.keys(config.modes);
+	if (ids.length === 0) return "session-mode: `modes` must declare at least one mode";
+	if (!ids.includes(config.default)) return `session-mode: \`default\` names ${JSON.stringify(config.default)}, which is not in modes (${ids.join(", ")})`;
+	const roleless = ids.filter((id) => roles(id).length === 0);
+	if (roleless.length > 0) return `session-mode: mode(s) ${roleless.join(", ")} declare no \`role\`; declare main and/or subagent instead of leaving it empty`;
+	if (!roles(config.default).includes("main")) return `session-mode: \`default\` names ${JSON.stringify(config.default)}, which does not declare role "main"; a session that can never be re-selected is a contradiction`;
+	const unknownPolicies = Object.entries(config.modes).flatMap(([id, mode]) => [...mode.allowPolicies ?? [], ...mode.denyPolicies ?? []].filter((policy) => !POLICY_NAME_SET.has(policy)).map((policy) => `${id}: ${policy}`));
+	if (unknownPolicies.length > 0) return `session-mode: mode(s) ${unknownPolicies.join(", ")} name unknown policies; the known ones are ${require_shared.POLICY_NAMES.join(", ")}`;
+	if (Object.keys(config.models ?? {}).length > 0) return "session-mode: `models` has moved into each mode's `defaultModel`; move the entries there and drop the top-level `models`";
+	const retiredPresets = Object.entries(config.modes).filter(([, mode]) => mode.preset !== void 0).map(([id]) => id);
+	if (retiredPresets.length > 0) return `session-mode: mode(s) ${retiredPresets.join(", ")} still declare \`preset\`; it has moved to \`presetsOnly\` (the presets that mode may ride on)`;
+	const partial = Object.entries(config.modes).filter(([, mode]) => {
+		const model = mode.defaultModel;
+		if (model === void 0) return false;
+		return model.provider === void 0 || model.model === void 0 || model.provider.length === 0 || model.model.length === 0;
+	}).map(([id]) => id);
+	if (partial.length > 0) return `session-mode: mode(s) ${partial.join(", ")} declare \`defaultModel\` without both \`provider\` and \`model\``;
+}
+//#endregion
+//#region src/persona.ts
+const PREFIX_ORDER = "DEPLOYMENT_PERSONA_PREFIX";
+const SUFFIX_ORDER = "DEPLOYMENT_PERSONA_SUFFIX";
+function installPersona(agent, persona) {
+	const prompt = agent.ctx.systemPrompt;
+	const disposers = [prompt.section({
+		name: _deepseek_ai_dsh_system_prompt.PERSONA_PREFIX_SECTION,
+		order: prompt.getSectionOrder(PREFIX_ORDER),
+		text: persona?.prefix ?? ""
+	}), prompt.section({
+		name: _deepseek_ai_dsh_system_prompt.PERSONA_SUFFIX_SECTION,
+		order: prompt.getSectionOrder(SUFFIX_ORDER),
+		text: persona?.suffix ?? ""
+	})];
+	return () => {
+		for (const dispose of disposers) dispose();
+	};
+}
+//#endregion
+//#region src/scope.ts
+const OUT_OF_SCOPE = (toolName, modeName) => `${toolName} 不在「${modeName}」的工具白名单里，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
+const DENYLISTED = (toolName, modeName) => `${toolName} 被「${modeName}」的工具黑名单排除，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
+function refusalOf(toolName, modeName, denial) {
+	return denial === "denylisted" ? DENYLISTED(toolName, modeName) : OUT_OF_SCOPE(toolName, modeName);
+}
+const SKILL_OUT_OF_SCOPE = (skillName, modeName) => `${skillName} 不在「${modeName}」的技能白名单里，加载它不会有结果；按当前模式可用的技能完成任务，或让用户切到别的模式。`;
+const SKILL_DENYLISTED = (skillName, modeName) => `${skillName} 被「${modeName}」的技能黑名单排除，加载它不会有结果；按当前模式可用的技能完成任务，或让用户切到别的模式。`;
+function skillRefusalOf(skillName, modeName, denial) {
+	return denial === "denylisted" ? SKILL_DENYLISTED(skillName, modeName) : SKILL_OUT_OF_SCOPE(skillName, modeName);
+}
+const TOOL_SECTION_PREFIX = "tool:";
+const SKILL_TOOL_NAME = "skill";
+function gateOfNames(allow, deny) {
+	const denied = new Set(deny);
+	const allowed = allow.length === 0 ? void 0 : new Set(allow);
+	if (allowed === void 0 && denied.size === 0) return void 0;
+	return {
+		allow: allowed,
+		deny: denied
+	};
+}
+function denialOf(gate, name) {
+	if (gate.deny.has(name)) return "denylisted";
+	if (gate.allow !== void 0 && !gate.allow.has(name)) return "not-allowlisted";
+}
+function kindOf(message) {
+	const kind = message.source.kind;
+	return typeof kind === "string" ? kind : void 0;
+}
+const CATALOG_LINE = /^- `([^`]+)`: /u;
+function narrowCatalog(message, gate, warn) {
+	const source = message.source;
+	if (source.kind !== "skill-catalog") return void 0;
+	const entries = source.entries;
+	const denied = new Set(entries.map((entry) => entry.name).filter((name) => denialOf(gate, name) !== void 0));
+	if (denied.size === 0) return void 0;
+	const [block, ...rest] = message.content;
+	if (block?.type !== "text" || rest.length > 0) {
+		warn(`skill catalog message is not one text block; denied skills stay listed: ${[...denied].join(", ")}`);
+		return;
+	}
+	const removed = /* @__PURE__ */ new Set();
+	const lines = block.text.split("\n").filter((line) => {
+		const match = CATALOG_LINE.exec(line);
+		if (match === null) return true;
+		const name = match[1] ?? "";
+		if (!denied.has(name)) return true;
+		removed.add(name);
+		return false;
+	});
+	const missing = [...denied].filter((name) => !removed.has(name));
+	if (missing.length > 0) {
+		warn(`skill catalog lines not recognized; denied skills stay listed: ${missing.join(", ")}`);
+		return;
+	}
+	return {
+		...message,
+		content: [{
+			...block,
+			text: lines.join("\n")
+		}]
+	};
+}
+function skillNameOf(arguments_) {
+	if (typeof arguments_ !== "object" || arguments_ === null) return void 0;
+	const name = arguments_.name;
+	return typeof name === "string" && name.length > 0 ? name : void 0;
+}
+var SessionScope = class {
+	applied = /* @__PURE__ */ new WeakMap();
+	ctx;
+	constructor(ctx) {
+		this.ctx = ctx;
+		ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+			const agent = context.agent;
+			const applied = agent === void 0 ? void 0 : this.applied.get(agent);
+			if (applied === void 0 || applied.gate === void 0) return next();
+			const gate = applied.gate;
+			const result = await next();
+			return {
+				...result,
+				sections: result.sections.filter((section) => section.name.startsWith(TOOL_SECTION_PREFIX) ? denialOf(gate, section.name.slice(5)) === void 0 : true),
+				tools: result.tools.filter((tool) => denialOf(gate, tool.name) === void 0)
+			};
+		});
+	}
+	apply(agent, definition) {
+		const previous = this.applied.get(agent);
+		if (previous !== void 0) previous.dispose();
+		const gate = gateOfNames(definition.allowTools, definition.denyTools);
+		const skillGate = gateOfNames(definition.allowSkills, definition.denySkills);
+		const dispose = agent.ctx.effect(() => {
+			const stoppers = [];
+			stoppers.push(agent.ctx.on("agent/pre-step", async (_payload, next) => {
+				const decision = await next();
+				if (decision.kind !== "enter") return decision;
+				const kept = this.suppress(decision.messages, definition, skillGate);
+				return kept === void 0 ? decision : {
+					...decision,
+					messages: kept
+				};
+			}, { prepend: true }));
+			if (definition.runtimeContext === false) stoppers.push(agent.ctx.systemPrompt.suppressRuntimeContext());
+			const fiber = agent.ctx.inject(["tools"], (scope) => {
+				if (gate === void 0 && skillGate === void 0) return;
+				scope.tools.guard((exec) => {
+					const denial = gate === void 0 ? void 0 : denialOf(gate, exec.name);
+					if (denial !== void 0) return refusalOf(exec.name, definition.name, denial);
+					if (skillGate === void 0 || exec.name !== SKILL_TOOL_NAME) return void 0;
+					const skillName = skillNameOf(exec.arguments);
+					if (skillName === void 0) return void 0;
+					const skillDenial = denialOf(skillGate, skillName);
+					return skillDenial === void 0 ? void 0 : skillRefusalOf(skillName, definition.name, skillDenial);
+				});
+			});
+			return [...stoppers, () => fiber.dispose()];
+		}, "session-mode: per-session gate");
+		this.channel()?.setInstructions(agent, definition.instructions);
+		this.applied.set(agent, {
+			gate,
+			dispose
+		});
+	}
+	suppress(messages, definition, skillGate) {
+		let changed = false;
+		const kept = [];
+		for (const message of messages) {
+			const kind = kindOf(message);
+			if (kind === "agent-instructions") {
+				if (definition.instructions) kept.push(message);
+				else changed = true;
+				continue;
+			}
+			if (kind === "skill-catalog") {
+				if (!definition.skills) {
+					changed = true;
+					continue;
+				}
+				const narrowed = skillGate === void 0 ? void 0 : narrowCatalog(message, skillGate, (line) => this.ctx.logger.warn(`session-mode: ${line}`));
+				if (narrowed === void 0) kept.push(message);
+				else {
+					changed = true;
+					kept.push(narrowed);
+				}
+				continue;
+			}
+			if (kind === "time-context") {
+				if (definition.runtimeContext) kept.push(message);
+				else changed = true;
+				continue;
+			}
+			kept.push(message);
+		}
+		return changed ? kept : void 0;
+	}
+	channel() {
+		try {
+			return this.ctx.get("contextAssembler");
+		} catch {
+			return;
+		}
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = "session-mode";
+const inject = [
+	"agents",
+	"sessions",
+	"sessionProjections",
+	"systemPrompt"
+];
+const sessionModeSchema = zod.z.union([zod.z.string(), zod.z.null()]);
+const sessionModeProjection = {
+	key: "sessionMode",
+	stateSchema: sessionModeSchema,
+	init: () => null,
+	apply: (state, event) => event.type === "session-mode/selected" ? event.data.sessionMode : state,
+	wire: {
+		viewSchema: sessionModeSchema,
+		view: (state) => state
+	},
+	stateVersion: 1
+};
+const sessionModeEditableSchema = zod.z.boolean();
+const sessionModeEditableProjection = {
+	key: "sessionModeEditable",
+	stateSchema: sessionModeEditableSchema,
+	init: () => true,
+	apply: (state, event) => state && event.type !== "turn/start",
+	wire: {
+		viewSchema: sessionModeEditableSchema,
+		view: (state) => state
+	},
+	stateVersion: 1
+};
+var SessionModes = class extends _deepseek_ai_cordis.Service {
+	installs = /* @__PURE__ */ new WeakMap();
+	scope;
+	config;
+	constructor(ctx, config) {
+		super(ctx, "sessionModes");
+		this.config = {
+			default: config.default.get(),
+			modes: structuredClone(config.modes.get())
+		};
+		const problem = configProblem({
+			...this.config,
+			models: config.models
+		});
+		if (problem !== void 0) throw new Error(problem);
+		this.scope = new SessionScope(ctx);
+		ctx.sessionProjections.register(sessionModeProjection);
+		ctx.sessionProjections.register(sessionModeEditableProjection);
+		ctx.on("fs/write-intent", (_target, actor, next) => this.decidePolicy("fs/write-intent", actor, next), { prepend: true });
+		ctx.on("fs/edit-intent", (_target, actor, next) => this.decidePolicy("fs/edit-intent", actor, next), { prepend: true });
+		ctx.on("agent/created", ({ agent }) => {
+			this.installFor(agent);
+		});
+		ctx.on("agent-preset/selected", (sessionId, preset) => {
+			const mapped = this.modeForPreset(preset);
+			const agent = ctx.agents.get(sessionId);
+			if (mapped === void 0 || agent === void 0) return;
+			if (this.ctx.sessionProjections.stateOf(agent.session, "sessionMode") !== mapped) agent.session.append("session-mode/selected", { sessionMode: mapped });
+			this.installFor(agent, mapped);
+		});
+	}
+	get defaultId() {
+		return this.config.default;
+	}
+	list() {
+		return this.idsFor("main").map((id) => {
+			const mode = this.definition(id);
+			return {
+				id,
+				name: mode.name,
+				...mode.description === "" ? {} : { description: mode.description }
+			};
+		});
+	}
+	idsFor(role) {
+		return Object.entries(this.config.modes).filter(([, mode]) => mode.role.includes(role)).map(([id]) => id);
+	}
+	modesFor(role) {
+		return this.idsFor(role).map((id) => ({
+			id,
+			mode: this.definition(id)
+		}));
+	}
+	roster() {
+		return {
+			default: this.defaultId,
+			modes: this.list()
+		};
+	}
+	definition(id) {
+		const wanted = id ?? this.defaultId;
+		const mode = this.config.modes[wanted];
+		if (mode === void 0) throw new Error(`未知的模式 ${JSON.stringify(wanted)}；可用的是 ${Object.keys(this.config.modes).join(", ")}`);
+		return mode;
+	}
+	modeOf(session) {
+		return this.ctx.sessionProjections.stateOf(session, "sessionMode") ?? this.defaultId;
+	}
+	modeOfSession(session) {
+		return this.definition(this.modeOf(session));
+	}
+	policyInForce(policy, actor) {
+		const agent = actor?.agent;
+		if (agent === void 0) return true;
+		const mode = this.config.modes[this.modeOf(agent.session)];
+		if (mode === void 0) return true;
+		if (mode.denyPolicies.includes(policy)) return false;
+		return mode.allowPolicies.length === 0 || mode.allowPolicies.includes(policy);
+	}
+	async decidePolicy(policy, actor, next) {
+		if (this.policyInForce(policy, actor)) return await next();
+		try {
+			await next();
+		} catch {}
+	}
+	async select(sessionId, mode) {
+		const definition = this.definition(mode);
+		if (!definition.role.includes("main")) throw new Error(`模式 ${JSON.stringify(mode)} 不是用户可选的（它的 role 里没有 main）。`);
+		const session = this.ctx.sessions.get(sessionId);
+		if (session === void 0) throw new Error(`未知的会话 ${sessionId}`);
+		if (this.ctx.sessionProjections.stateOf(session, "sessionModeEditable") === false) throw new Error("这个会话已经开始，模式不能再改；要换模式请新开一个会话。");
+		const agent = this.ctx.agents.get(sessionId);
+		const registry = this.presetRegistry();
+		if (agent !== void 0 && registry !== void 0) {
+			const target = this.presetTarget(definition.presetsOnly, this.presetOfAgent(registry, agent));
+			if (target !== void 0) await registry.select(agent, target);
+		}
+		if (this.ctx.sessionProjections.stateOf(session, "sessionMode") !== mode) session.append("session-mode/selected", { sessionMode: mode });
+		if (agent !== void 0) this.installFor(agent);
+		return mode;
+	}
+	presetTarget(allowed, current) {
+		if (allowed.length === 0) return void 0;
+		if (current !== void 0 && allowed.includes(current)) return void 0;
+		const target = allowed[0];
+		return target === current ? void 0 : target;
+	}
+	presetOfAgent(registry, agent) {
+		const read = registry.composedPreset;
+		if (typeof read !== "function") return void 0;
+		try {
+			return read.call(registry, agent.ctx);
+		} catch {
+			return;
+		}
+	}
+	presetRegistry() {
+		try {
+			return this.ctx.get("agentPresets");
+		} catch {
+			return;
+		}
+	}
+	applyTo(agent, mode, options = {}) {
+		this.definition(mode);
+		if (options.record !== false) agent.session.append("session-mode/selected", { sessionMode: mode });
+		this.installFor(agent, mode);
+	}
+	resolveModeId(agent) {
+		const selected = this.ctx.sessionProjections.stateOf(agent.session, "sessionMode");
+		if (typeof selected === "string") return selected;
+		const mapped = this.modeForPreset(this.presetOf(agent.session));
+		if (mapped !== void 0) {
+			agent.session.append("session-mode/selected", { sessionMode: mapped });
+			return mapped;
+		}
+		const inherited = this.inheritedModeId(agent);
+		if (inherited === void 0) return this.defaultId;
+		agent.session.append("session-mode/selected", { sessionMode: inherited });
+		return inherited;
+	}
+	presetOf(session) {
+		try {
+			const state = this.ctx.sessionProjections.stateOf(session, "agentPreset");
+			return typeof state === "string" ? state : void 0;
+		} catch {
+			return;
+		}
+	}
+	modeForPreset(preset) {
+		if (preset === void 0) return void 0;
+		const owners = Object.keys(this.config.modes).filter((id) => this.config.modes[id]?.presetsOnly.includes(preset));
+		return owners.length === 1 ? owners[0] : void 0;
+	}
+	inheritedModeId(agent) {
+		const parentId = agent.session.header.parentSession;
+		if (parentId === void 0) return void 0;
+		const parent = this.ctx.agents.get(parentId);
+		return parent === void 0 ? void 0 : this.modeOf(parent.session);
+	}
+	installFor(agent, modeId = this.resolveModeId(agent)) {
+		const installed = this.installs.get(agent);
+		if (installed?.mode === modeId) return;
+		installed?.dispose();
+		const mode = this.definition(modeId);
+		const disposers = [installPersona(agent, mode.persona), this.installDefaultModel(agent, modeId)];
+		this.installs.set(agent, {
+			mode: modeId,
+			dispose: () => {
+				for (const dispose of disposers) dispose();
+			}
+		});
+		this.scope.apply(agent, {
+			name: mode.name,
+			allowTools: mode.allowTools,
+			denyTools: mode.denyTools,
+			allowSkills: mode.allowSkills,
+			denySkills: mode.denySkills,
+			instructions: mode.instructions,
+			skills: mode.skills ?? derivedSkills(mode),
+			runtimeContext: mode.runtimeContext
+		});
+	}
+	installDefaultModel(agent, modeId) {
+		return agent.ctx.on("agent/request", async (_payload, next) => {
+			const resolved = await next();
+			const model = this.config.modes[modeId]?.defaultModel;
+			if (model === void 0) return resolved;
+			const pending = this.ctx.sessionProjections.stateOf(agent.session, "modelSelection")?.pending;
+			if (pending !== void 0 && pending !== null) return resolved;
+			if (agent.session.requestHeader() !== void 0) return resolved;
+			return {
+				...resolved,
+				provider: model.provider,
+				model: model.model,
+				...model.reasoningEffort === void 0 ? {} : { reasoningEffort: (0, _deepseek_ai_dsh_llm.ReasoningEffortId)(model.reasoningEffort) }
+			};
+		});
+	}
+};
+function apply(ctx, config) {
+	registerHttpRoutes(ctx, new SessionModes(ctx, config));
+	ctx.plugin(require_catalog.SessionModeCatalog);
+}
+function respondJson(response, status, body) {
+	response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	response.end(JSON.stringify(body));
+}
+function requestJson(request) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		request.on("data", (chunk) => {
+			chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+		});
+		request.on("end", () => {
+			try {
+				resolve(chunks.length === 0 ? void 0 : JSON.parse(chunks.join("")));
+			} catch {
+				reject(/* @__PURE__ */ new TypeError("请求体不是合法 JSON。"));
+			}
+		});
+		request.on("error", reject);
+	});
+}
+function requiredString(value, field) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError(`${field} 必须是非空字符串。`);
+	return value;
+}
+async function handleRoute(modes, request, response) {
+	try {
+		if (request.method === "GET") {
+			respondJson(response, 200, modes.roster());
+			return;
+		}
+		if (request.method === "POST") {
+			const body = await requestJson(request);
+			if (typeof body !== "object" || body === null || Array.isArray(body)) throw new TypeError("请求体必须是 JSON 对象。");
+			const record = body;
+			const sessionId = requiredString(record["sessionId"], "sessionId");
+			const mode = requiredString(record["mode"], "mode");
+			respondJson(response, 200, { mode: await modes.select(sessionId, mode) });
+			return;
+		}
+		response.writeHead(405);
+		response.end();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		respondJson(response, error instanceof TypeError ? 400 : 409, { error: message });
+	}
+}
+function registerHttpRoutes(ctx, modes) {
+	ctx.inject(["webServer"], (scope) => {
+		const webServer = scope.get("webServer");
+		if (webServer === void 0) return;
+		scope.effect(() => webServer.register({
+			kind: "exact",
+			path: require_shared.SESSION_MODE_PATH,
+			handler: (request, response) => handleRoute(modes, request, response)
+		}), "session-mode: HTTP route");
+	});
+}
+//#endregion
+exports.Config = Config;
+exports.POLICY_NAMES = require_shared.POLICY_NAMES;
+exports.SESSION_MODE_PATH = require_shared.SESSION_MODE_PATH;
+exports.SessionModes = SessionModes;
+exports.apply = apply;
+exports.inject = inject;
+exports.name = name;
+exports.sessionModeEditableProjection = sessionModeEditableProjection;
+exports.sessionModeProjection = sessionModeProjection;

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 import { Context, Service, Volatile } from "@deepseek-ai/cordis";
-import { z } from "zod";
-import z$1 from "@deepseek-ai/schemastery";
 import { Agent } from "@deepseek-ai/dsh-agent";
 import { Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
+import { z } from "zod";
+import z$1 from "@deepseek-ai/schemastery";
 //#region src/modes.d.ts
 interface SessionModePersona {
   readonly prefix: string;