dsh-compaction-tower 0.0.0-stage → 0.1.39

package/lib/config-store.js

@@ -0,0 +1,146 @@
+/**
+ * Tower 的配置存储：把「界面上改的值」与「profile 里写的值」分开保存。
+ *
+ * 优先级：用户覆盖（本文件） > profile 条目配置（cordis.patch.yml 里的 config:） > DEFAULTS。
+ * 落盘位置：`<DSH_HOME>/storages/compaction-tower/config.json`，与宿主自己的 storages 同级，
+ * 只存用户改过的键（稀疏），删掉这个文件就回到 YAML 里的值。
+ *
+ * 写入是原子的：先写同目录临时文件再 rename，避免半个 JSON 让下次启动读不出来。
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import { DEFAULTS, FIELDS, pickPatch, resolveConfig } from './config.js';
+
+/** 覆盖配置文件的位置（跟随 DSH_HOME，沙盒里就是沙盒的 home）。 */
+export function configPath() {
+  return dshHomePath('storages', 'compaction-tower', 'config.json');
+}
+
+export class ConfigStore {
+  /**
+   * @param {object} entryConfig profile 条目里写的配置（可能是空对象）
+   */
+  constructor(entryConfig = {}) {
+    this.entry = { ...entryConfig };
+    this.overrides = {};
+    this.revision = 0;
+    this.path = configPath();
+    this.loadProblem = undefined;
+    /** @type {((next: object) => void) | undefined} 生效后的回调（把新值推给 Tower） */
+    this.onChange = undefined;
+    this.reload();
+  }
+
+  /** 从磁盘读覆盖层并算出当前生效配置。坏文件只记问题，不阻止启动。 */
+  reload() {
+    this.overrides = {};
+    this.loadProblem = undefined;
+    try {
+      const raw = readFileSync(this.path, 'utf8');
+      const parsed = JSON.parse(raw);
+      if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        this.overrides = pickPatch(parsed);
+      } else {
+        this.loadProblem = '配置文件不是一个 JSON 对象，已忽略';
+      }
+    } catch (error) {
+      if (error?.code !== 'ENOENT') this.loadProblem = `读取 ${this.path} 失败：${error?.message ?? error}`;
+    }
+    this.effective = resolveConfig({ ...this.entry, ...this.overrides });
+    return this.effective;
+  }
+
+  /** 当前生效配置。 */
+  get config() {
+    return this.effective;
+  }
+
+  /**
+   * 合并一批改动并落盘。
+   * @param {object} patch 只含要改的键
+   * @returns {object} 新的生效配置
+   */
+  save(patch) {
+    const clean = pickPatch(patch);
+    const nextOverrides = { ...this.overrides, ...clean };
+    const nextEffective = resolveConfig({ ...this.entry, ...nextOverrides });
+    this.persist(nextOverrides);
+    this.overrides = nextOverrides;
+    this.effective = nextEffective;
+    this.revision += 1;
+    this.onChange?.(nextEffective);
+    return nextEffective;
+  }
+
+  /**
+   * 去掉若干键的覆盖，回到 profile / 默认值。
+   * @param {string[]} keys 要恢复的键
+   * @returns {object} 新的生效配置
+   */
+  reset(keys) {
+    if (!Array.isArray(keys) || keys.length === 0) throw new Error('tower: reset 需要至少一个键');
+    const nextOverrides = { ...this.overrides };
+    for (const key of keys) {
+      if (!(key in DEFAULTS)) throw new Error(`tower: 未知配置项 "${key}"`);
+      delete nextOverrides[key];
+    }
+    const nextEffective = resolveConfig({ ...this.entry, ...nextOverrides });
+    this.persist(nextOverrides);
+    this.overrides = nextOverrides;
+    this.effective = nextEffective;
+    this.revision += 1;
+    this.onChange?.(nextEffective);
+    return nextEffective;
+  }
+
+  persist(overrides) {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const temp = `${this.path}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(overrides, null, 2)}\n`, 'utf8');
+    renameSync(temp, this.path);
+  }
+
+  /** 给配置界面用的快照：字段元数据 + 三个来源的值。 */
+  snapshot() {
+    const groups = [];
+    const byGroup = new Map();
+    for (const field of FIELDS) {
+      if (!byGroup.has(field.group)) {
+        const group = { title: field.group, fields: [] };
+        byGroup.set(field.group, group);
+        groups.push(group);
+      }
+      const value = this.effective[field.key];
+      byGroup.get(field.group).fields.push({
+        key: field.key,
+        label: field.label,
+        type: field.type,
+        min: field.min,
+        max: field.max,
+        step: field.step,
+        unit: field.unit,
+        hint: field.hint,
+        source: field.source,
+        pairKey: field.pairKey,
+        options: field.options,
+        rows: field.rows,
+        placeholder: field.placeholder,
+        modeKey: field.modeKey,
+        presetFor: field.presetFor,
+        targetKey: field.targetKey,
+        value,
+        percent: field.type === 'ratio' ? Math.round(value * 1000) / 10 : undefined,
+        default: DEFAULTS[field.key],
+        base: this.entry[field.key] ?? DEFAULTS[field.key],
+        override: Object.hasOwn(this.overrides, field.key),
+      });
+    }
+    return {
+      path: this.path,
+      revision: this.revision,
+      groups,
+      problem: this.loadProblem,
+    };
+  }
+}

package/lib/config.js

@@ -0,0 +1,323 @@
+/**
+ * Tower 的配置：全部是比例，随模型上下文窗口自适应。
+ *
+ * 这里只做「默认值 + 校验 + 字段元数据」，不做任何 IO。
+ * 三处共用同一份事实：DEFAULTS（默认值）、Config（schemastery，给宿主）、
+ * FIELDS（配置界面用的标签/说明/范围）。
+ */
+import z from '@deepseek-ai/schemastery';
+
+/** 默认值。改这里等于改所有未显式配置的部署。 */
+export const DEFAULTS = Object.freeze({
+  /** 占用超过比例才提交 */
+  triggerRatio: 0.45,
+  /** 提交到此为止（尽力而为） */
+  targetRatio: 0.15,
+  /** 观察者认为「值得蒸馏」的最小 run 占比 */
+  distillMinRunRatio: 0.05,
+  /** 最近 N 个 step 永不提交（蒸馏不受限） */
+  retainRecentGroups: 10,
+  /**
+   * 单个块原文的 token 上限。
+   *
+   * 这是保险丝，不是常规截断点：正常的上下文窗口（数百 K）里，
+   * 一段该被压缩的历史几乎不可能到 200K；真到了就说明模型在刷垃圾输出，
+   * 这时截断反而是对的。所以默认给到很大，只拦住失控的情况。
+   */
+  observerMaxTokens: 200000,
+  /** 观察者用的 provider（空 = 跟随当前会话） */
+  observerProvider: '',
+  /** 观察者用的 model（空 = 跟随当前会话） */
+  observerModel: '',
+  /**
+   * 每层的目标库存（几个单位）。
+   *
+   * 越线后要能从触发线一路压到目标线，所以库存 = (触发线 − 目标线) / 一个单位，再加 1 个安全垫。
+   * 每层各自计数：低层块顶不了高层的缺（提交顺序是低层优先）。
+   */
+  /** @deprecated 已改为按 (触发线−目标线)/单位 自动推导（见 reserveUnitsOf）；保留键只为兼容已存的旧配置 */
+  observerReserveUnits: 4,
+  /** 一次最多同时发起几个蒸馏（并发块数，每个都是一次付费调用） */
+  observerConcurrency: 10,
+  /** 单次蒸馏超时（毫秒） */
+  observerTimeoutMs: 120000,
+  /** 蒸馏提示词用哪一套：host（宿主英文原文）| zh（中文预设）| custom（自己写） */
+  summaryPromptMode: 'host',
+  /** 自定义蒸馏提示词（仅 summaryPromptMode === 'custom' 时使用） */
+  summaryPrompt: '',
+  /** 摘要输出上限（保险丝）：接管那次请求时必须显式给足，否则会被模型的默认上限腰斩 */
+  summaryMaxTokens: 200000,
+  /** 解压内容内联的阈值（占预算比例） */
+  inlineMaxRatio: 0.02,
+  /** 单次解压的绝对上限 */
+  hardMaxTokens: 40000,
+  /** 保留最近 N 个导出会话目录 */
+  exportKeepSessions: 20,
+  /** 相邻 checkpoint 达到几个才值得合并成上层块 */
+  mergeMinBlocks: 2,
+});
+
+export const Config = z.object({
+  triggerRatio: z.number().min(0.001).max(0.95).default(DEFAULTS.triggerRatio),
+  targetRatio: z.number().min(0.0001).max(0.9).default(DEFAULTS.targetRatio),
+  distillMinRunRatio: z.number().min(0.00001).max(0.5).default(DEFAULTS.distillMinRunRatio),
+  retainRecentGroups: z.number().step(1).min(0).default(DEFAULTS.retainRecentGroups),
+  observerMaxTokens: z.number().step(1).min(1000).default(DEFAULTS.observerMaxTokens),
+  observerProvider: z.string().default(DEFAULTS.observerProvider),
+  observerModel: z.string().default(DEFAULTS.observerModel),
+  observerReserveUnits: z.number().step(1).min(0).default(DEFAULTS.observerReserveUnits),
+  observerConcurrency: z.number().step(1).min(1).max(16).default(DEFAULTS.observerConcurrency),
+  observerTimeoutMs: z.number().step(1000).min(1000).default(DEFAULTS.observerTimeoutMs),
+  summaryPromptMode: z.string().default(DEFAULTS.summaryPromptMode),
+  summaryPrompt: z.string().default(DEFAULTS.summaryPrompt),
+  summaryMaxTokens: z.number().step(1).min(0).default(DEFAULTS.summaryMaxTokens),
+  inlineMaxRatio: z.number().min(0.001).max(0.5).default(DEFAULTS.inlineMaxRatio),
+  hardMaxTokens: z.number().step(1).min(1000).default(DEFAULTS.hardMaxTokens),
+  exportKeepSessions: z.number().step(1).min(1).default(DEFAULTS.exportKeepSessions),
+  mergeMinBlocks: z.number().step(1).min(2).default(DEFAULTS.mergeMinBlocks),
+});
+
+/**
+ * 配置界面的字段元数据。数组顺序即显示顺序，`group` 决定分栏。
+ * `type`：ratio 是 0..1 的比例，int 是整数，bool 开关，text 自由文本，
+ * textarea 多行文本（提示词用，`rows` 是行数），
+ * select 是下拉——`options` 是固定的候选项；`source: 'provider' | 'model'` 表示候选项
+ * 从宿主的模型目录里取，`pairKey` 指向它跟随的 provider 字段（选 provider 后只列该家的模型）。
+ */
+export const FIELDS = Object.freeze([
+  {
+    key: 'triggerRatio',
+    group: '触发与目标',
+    label: '触发线',
+    type: 'ratio',
+    min: 0.001,
+    max: 0.95,
+    step: 0.01,
+    hint: '内容占用超过「可用预算」的这个比例才开始提交。0.45 即 45%。可用预算 = 窗口 − system 提示词 − 工具 schema（它们恒占窗口、永不压缩，所以不进分母）。',
+  },
+  {
+    key: 'targetRatio',
+    group: '触发与目标',
+    label: '目标线',
+    type: 'ratio',
+    min: 0.0001,
+    max: 0.9,
+    step: 0.01,
+    hint: '提交做到可用预算的这个比例就停。必须小于触发线；材料不够时停在能到的位置。',
+  },
+  {
+    key: 'distillMinRunRatio',
+    group: '观察者',
+    label: '单块分量',
+    type: 'ratio',
+    min: 0.00001,
+    max: 0.5,
+    step: 0.005,
+    hint: '一次蒸馏（或一次合并）的材料量，占可用预算的比例。材料不足这份量就不动手；够了就切这么一块，剩下的原文留在表层等下一回合。0.05 即 5%。',
+  },
+  {
+    key: 'retainRecentGroups',
+    group: '观察者',
+    label: '保留最近步数',
+    type: 'int',
+    min: 0,
+    max: 200,
+    step: 1,
+    unit: '步',
+    hint: '最近 N 个 step（一次模型请求 = 一步）永不进入蒸馏候选。按用户轮次算会把整段新对话都圈进保护区，所以按步算。0 表示不保护（仅调试用）。',
+  },
+  {
+    key: 'observerMaxTokens',
+    group: '观察者',
+    label: '单块原文上限',
+    type: 'int',
+    min: 1000,
+    max: 400000,
+    step: 1000,
+    unit: 'token',
+    hint: '绝对保险丝：单块绝不会超过它。正常单块 = 可用预算的「单块分量」（5%），只有单个节点本身就超过分量时才会碰到它；也用来把分量封顶（设得比分量小就以它为准）。',
+  },
+  {
+    key: 'observerTimeoutMs',
+    group: '观察者',
+    label: '蒸馏超时',
+    type: 'int',
+    min: 1000,
+    max: 600000,
+    step: 1000,
+    unit: '毫秒',
+    hint: '回合结束会等蒸馏完成再关会话；超过这个时间就放弃这一次，块不写入。',
+  },
+  {
+    key: 'observerProvider',
+    group: '观察者',
+    label: '观察者 provider',
+    type: 'select',
+    source: 'provider',
+    hint: '蒸馏用哪个 provider。留空跟随当前会话。',
+  },
+  {
+    key: 'observerModel',
+    group: '观察者',
+    label: '观察者 model',
+    type: 'select',
+    source: 'model',
+    pairKey: 'observerProvider',
+    hint: '蒸馏用哪个模型。留空跟随当前会话；选了 provider 时只列出那个 provider 的模型。',
+  },
+  
+  {
+    key: 'observerConcurrency',
+    group: '观察者',
+    label: '并发蒸馏',
+    type: 'int',
+    min: 1,
+    max: 16,
+    step: 1,
+    unit: '个',
+    hint: '一次最多同时发起几个蒸馏。从最底层开始发名额，发满就停：低层有料就先蒸低层。',
+  },
+  {
+    key: 'summaryPromptMode',
+    group: '观察者',
+    label: '蒸馏提示词',
+    type: 'select',
+    targetKey: 'summaryPrompt',
+    options: [
+      { value: 'host', label: '宿主（英文原文）' },
+      { value: 'zh', label: '中文版（同结构）' },
+      { value: 'custom', label: '自定义' },
+    ],
+    hint: '宿主：调用宿主的 summarize，用它的英文指令（默认，格式与宿主原生压缩一致）。中文版：同样的 8 段结构，正文改中文。自定义：用下面那段文本，自己发这次请求；改之前先切成自定义。',
+  },
+  {
+    key: 'summaryPrompt',
+    group: '观察者',
+    label: '自定义蒸馏提示词',
+    type: 'textarea',
+    rows: 10,
+    placeholder: '留空 = 用宿主英文原文',
+    modeKey: 'summaryPromptMode',
+    presetFor: { host: 'summaryHost', zh: 'summaryZh' },
+    hint: '选了预设时这里只读显示那段预设的原文；切到「自定义」才可编辑。建议保留 8 个英文小节标题——它是「下一个模型能接手」的结构约定。',
+  },
+  {
+    key: 'summaryMaxTokens',
+    group: '观察者',
+    label: '摘要输出上限',
+    type: 'int',
+    min: 0,
+    max: 400000,
+    step: 1000,
+    unit: 'token',
+    hint: '只管中文版 / 自定义档这一次请求的输出上限（宿主档仍用宿主自己的 65536）。它是防失控的保险丝，不是用来剪摘要的：正常摘要几 K 就停笔，200000 永远碰不到。调小会让摘要撞上限 → 这一块整块作废（宁可这次不压，也不拿半截摘要覆盖原文）。0 = 不传上限，交给适配器的默认值。',
+  },
+  {
+    key: 'mergeMinBlocks',
+    group: '塔',
+    label: '合并块数下限',
+    type: 'int',
+    min: 2,
+    max: 16,
+    step: 1,
+    unit: '个',
+    hint: '一次合并至少要几个同层 checkpoint。真正决定「什么时候值得合并」的是材料总量要攒到可用预算的 5%（与蒸馏共用 distillMinRunRatio）；这个数只是下限。',
+  },
+  {
+    key: 'exportKeepSessions',
+    group: '塔',
+    label: '导出目录保留',
+    type: 'int',
+    min: 1,
+    max: 200,
+    step: 1,
+    unit: '个会话',
+    hint: '解压内容落盘到 <项目>/.dsh/tower/ 时，只保留最近几个会话的目录。',
+  },
+  {
+    key: 'inlineMaxRatio',
+    group: '解压',
+    label: '内联阈值',
+    type: 'ratio',
+    min: 0.001,
+    max: 0.5,
+    step: 0.005,
+    hint: '解压内容小于窗口的这个比例就直接回给模型，否则写文件并给路径。',
+  },
+  {
+    key: 'hardMaxTokens',
+    group: '解压',
+    label: '硬上限',
+    type: 'int',
+    min: 1000,
+    max: 400000,
+    step: 1000,
+    unit: 'token',
+    hint: '单次解压返回的绝对上限，超过就截断并说明。',
+  },
+]);
+
+const KEYS = new Set(Object.keys(DEFAULTS));
+
+/**
+ * 校验并冻结配置。
+ * @param {object} raw 宿主传入的原始配置（通常已经和用户覆盖合并过）。
+ * @returns {object} 深冻结的配置。
+ */
+export function resolveConfig(raw = {}) {
+  for (const key of Object.keys(raw)) {
+    if (!KEYS.has(key)) {
+      throw new Error(`tower: unknown config key "${key}" (allowed: ${[...KEYS].join(', ')})`);
+    }
+  }
+  const resolved = { ...DEFAULTS, ...raw };
+  if (!(resolved.targetRatio < resolved.triggerRatio)) {
+    throw new Error(`tower: 目标线（${resolved.targetRatio}）必须小于触发线（${resolved.triggerRatio}）`);
+  }
+  if (!Number.isFinite(resolved.hardMaxTokens) || resolved.hardMaxTokens <= 0) {
+    throw new Error(`tower: hardMaxTokens（${resolved.hardMaxTokens}）必须是正数`);
+  }
+  for (const field of FIELDS) {
+    const value = resolved[field.key];
+    if (field.type === 'int') {
+      if (!Number.isFinite(value) || !Number.isInteger(value)) {
+        throw new Error(`tower: ${field.label}（${field.key}）必须是整数`);
+      }
+    }
+    if (field.type === 'ratio' && (!Number.isFinite(value) || value <= 0 || value >= 1)) {
+      throw new Error(`tower: ${field.label}（${field.key}）必须在 0 与 1 之间`);
+    }
+    if (typeof field.min === 'number' && value < field.min) {
+      throw new Error(`tower: ${field.label}（${field.key}）不能小于 ${field.min}`);
+    }
+    if (typeof field.max === 'number' && value > field.max) {
+      throw new Error(`tower: ${field.label}（${field.key}）不能大于 ${field.max}`);
+    }
+    if (field.type === 'bool' && typeof value !== 'boolean') {
+      throw new Error(`tower: ${field.label}（${field.key}）必须是 true / false`);
+    }
+    if ((field.type === 'text' || field.type === 'select' || field.type === 'textarea') && typeof value !== 'string') {
+      throw new Error(`tower: ${field.label}（${field.key}）必须是字符串`);
+    }
+    if (field.type === 'select' && Array.isArray(field.options) && !field.options.some((option) => option.value === value)) {
+      throw new Error(`tower: ${field.label}（${field.key}）只能是 ${field.options.map((option) => option.value).join(' / ')}`);
+    }
+    if (field.type === 'textarea' && value.length > 100000) {
+      throw new Error(`tower: ${field.label}（${field.key}）太长了（上限 100000 字符）`);
+    }
+  }
+  return Object.freeze(resolved);
+}
+
+/** 只接受已知字段的补丁（配置界面用；未知键直接拒，别静默丢掉）。 */
+export function pickPatch(raw) {
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+    throw new Error('tower: 配置补丁必须是一个对象');
+  }
+  const patch = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (!KEYS.has(key)) throw new Error(`tower: 未知配置项 "${key}"`);
+    patch[key] = value;
+  }
+  return patch;
+}