@ftai/dsh-plugin-acn 0.0.0-stage → 0.1.0

package/lib/service-CNjqHCBR.js

@@ -0,0 +1,505 @@
+import { c as TranscriptStore, d as RecapOutputSchema, l as processedThrough, o as RouteSchema, r as structuredCall } from "./structured-lyQCK-Zk.js";
+import { C as StoreError, _ as JobError, b as Preempted, l as writeYamlAtomic, n as withFileLock } from "./lock-DbmlKOoX.js";
+import { n as recapClaimIds, t as prepareFormation } from "./prepare-DwHZudbA.js";
+import { n as FormationStore } from "./checkpoint-Bmt8q2vB.js";
+import { t as DurableWorker } from "./worker-BBTYP2RE.js";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+//#region src/formation/triggers.ts
+function idleTrigger(config, state, entries, now) {
+	if (!config.idleRecap || state.autoPaused || state.archiveIntent !== null || state.activityAt === 0) return;
+	const cursor = processedThrough(state);
+	const pending = entries.filter((entry) => entry.seq > cursor);
+	if (!pending.some((entry) => entry.text.trim() !== "")) return;
+	const elapsed = now - state.activityAt;
+	const turns = state.completedTurns.filter((end) => end > cursor).length;
+	const tokens = Math.ceil(pending.reduce((bytes, entry) => bytes + Buffer.byteLength(entry.text, "utf8"), 0) / 4);
+	if ((turns >= config.recapMinTurns || tokens >= config.recapMinTokens) && elapsed >= config.recapBatchIdleMinutes * 6e4) return "batch-idle";
+	if (elapsed >= config.recapTailIdleMinutes * 6e4) return "tail-idle";
+}
+//#endregion
+//#region src/formation/capture.ts
+var ProjectionFailure = class extends JobError {
+	code;
+	constructor(kind, message, code) {
+		super(kind, message);
+		this.code = code;
+	}
+};
+const ioCodes = [
+	"EPERM",
+	"EACCES",
+	"EBUSY",
+	"EAGAIN",
+	"EMFILE",
+	"ENFILE",
+	"ENOSPC",
+	"EDQUOT",
+	"EIO",
+	"ENOENT"
+];
+function formationFault(error) {
+	let current = error;
+	for (let depth = 0; depth < 8 && typeof current === "object" && current !== null; depth += 1) {
+		if (current instanceof ProjectionFailure) return current.code;
+		const code = "code" in current ? current.code : void 0;
+		if (ioCodes.some((value) => value === code)) return String(code);
+		if (current instanceof JobError && [
+			"transcript",
+			"transcript_limit",
+			"transcript_source"
+		].includes(current.kind)) return current.kind;
+		if (current instanceof StoreError && current.kind !== "io") return current.kind;
+		current = "cause" in current ? current.cause : void 0;
+	}
+	return "unknown";
+}
+async function retryFormation(action) {
+	for (let attempt = 0;; attempt += 1) try {
+		return await action();
+	} catch (error) {
+		if (attempt >= 2 || ![
+			"EPERM",
+			"EACCES",
+			"EBUSY",
+			"EAGAIN",
+			"EMFILE",
+			"ENFILE",
+			"lock_timeout"
+		].includes(formationFault(error))) throw error;
+		await setTimeout$1(50 * (attempt + 1));
+	}
+}
+function projectionError(error, stage, seq) {
+	const code = formationFault(error);
+	const kind = code === "transcript_limit" ? "transcript_limit" : ["ENOSPC", "EDQUOT"].includes(code) ? "transcript_space" : [
+		"EPERM",
+		"EACCES",
+		"EBUSY",
+		"EAGAIN",
+		"EMFILE",
+		"ENFILE",
+		"lock_timeout"
+	].includes(code) ? "transcript_occupied" : [
+		"transcript",
+		"decode",
+		"conflict"
+	].includes(code) ? "transcript_corrupt" : code === "transcript_source" ? "transcript_source" : "transcript_io";
+	const hint = kind === "transcript_limit" ? "单条投影超过容量限制，无法自动跳过；请保留原会话并联系维护者处理。" : kind === "transcript_space" ? "存储空间或配额不足；请释放空间后重试。" : kind === "transcript_occupied" ? "文件暂不可写或锁等待超时，有限重试仍未恢复；请检查文件占用和目录权限后重试。" : kind === "transcript_corrupt" ? "本地投影存在损坏或冲突，未跳过缺失内容；请保留数据并联系维护者。" : kind === "transcript_source" ? "无法读取原会话日志来补齐投影；请恢复原会话及其工作配置后重试。" : "本地会话投影读写失败；请检查本地存储状态后重试。";
+	return new ProjectionFailure(kind, `复盘输入尚未完整准备（${stage}${seq === void 0 ? "" : `，seq=${seq}`}，${code}）。${hint} 修复后在活动页重试原任务，或再次复盘；本次未调用知识模型。`, code);
+}
+var FormationCapture = class {
+	transcript;
+	replay;
+	buffers = /* @__PURE__ */ new Map();
+	blocked = /* @__PURE__ */ new Map();
+	restored = /* @__PURE__ */ new Set();
+	constructor(transcript, replay) {
+		this.transcript = transcript;
+		this.replay = replay;
+	}
+	add(id, projection) {
+		const rows = this.buffers.get(id) ?? [];
+		rows.push(projection);
+		this.buffers.set(id, rows);
+	}
+	async drain(id, retry = false) {
+		const failure = this.blocked.get(id);
+		if (!retry && failure !== void 0) throw failure;
+		const rows = this.buffers.get(id);
+		while (rows !== void 0 && rows.length > 0) {
+			const projection = rows[0];
+			if (projection === void 0) break;
+			try {
+				await retryFormation(() => this.transcript.record(id, projection));
+			} catch (error) {
+				const failure = projectionError(error, "projection", projection.entry?.seq ?? projection.activity?.seq);
+				this.blocked.set(id, failure);
+				throw failure;
+			}
+			rows.shift();
+		}
+		this.buffers.delete(id);
+		this.blocked.delete(id);
+	}
+	async prepare(id) {
+		await this.drain(id, true);
+		if (!this.restored.has(id) && this.replay !== void 0) try {
+			const projections = await retryFormation(() => this.replay?.(id) ?? Promise.resolve([]));
+			await retryFormation(() => this.transcript.replay(id, projections));
+			this.restored.add(id);
+		} catch (error) {
+			throw projectionError(error, "replay");
+		}
+	}
+	ids() {
+		return [...this.buffers.keys()];
+	}
+};
+//#endregion
+//#region src/formation/service.ts
+var AcnFormation = class {
+	knowledge;
+	backend;
+	render;
+	routeReady;
+	worker;
+	transcript;
+	pending = Promise.resolve();
+	captures;
+	compactions = /* @__PURE__ */ new Map();
+	archiveChecks = /* @__PURE__ */ new Map();
+	archiveView;
+	timers = /* @__PURE__ */ new Map();
+	attached = /* @__PURE__ */ new Set();
+	activeSessions = /* @__PURE__ */ new Set();
+	scanner;
+	started = false;
+	closing = false;
+	closeTask;
+	unregister;
+	ownsWorker;
+	constructor(knowledge, backend, render, workerOptions = {}, worker, routeReady, replay) {
+		this.knowledge = knowledge;
+		this.backend = backend;
+		this.render = render;
+		this.routeReady = routeReady;
+		this.worker = worker ?? new DurableWorker(knowledge.context(), workerOptions);
+		this.ownsWorker = worker === void 0;
+		this.transcript = new TranscriptStore(knowledge.context());
+		this.captures = new FormationCapture(this.transcript, replay);
+		this.unregister = [this.worker.register("recap", (job, control) => this.run(job, control)), this.worker.register("finalize", (job, control) => this.run(job, control))];
+	}
+	async start() {
+		await new FormationStore(this.knowledge.context()).recover();
+		for (const id of await this.transcript.sessions(true)) try {
+			await this.captures.prepare(id);
+			await this.transcript.record(id, {});
+			if ((await this.transcript.state(id)).archivePending) await this.finishArchive(id);
+		} catch (error) {
+			this.report("replay", id, error);
+		}
+		await this.worker.start();
+		this.started = true;
+		this.scanner = setInterval(() => {
+			this.schedule("scan", void 0, () => this.scanPending(Date.now()));
+		}, this.knowledge.config.formation.recapScanSeconds * 1e3);
+		this.scanner.unref();
+		await this.scanPending(Date.now());
+	}
+	attach(id) {
+		this.attached.add(id);
+		this.idle(id);
+	}
+	capture(id, projection, compactedUntil) {
+		if (this.closing) return;
+		this.schedule("projection", id, async () => {
+			this.captures.add(id, projection);
+			if (compactedUntil !== void 0 && this.knowledge.config.formation.recapOnCompaction) this.compactions.set(id, Math.max(this.compactions.get(id) ?? -1, compactedUntil));
+			await this.captures.drain(id);
+			if (projection.route !== void 0) {
+				const route = projection.route;
+				try {
+					await retryFormation(() => this.rememberRoute(route));
+				} catch (error) {
+					this.report("route", id, error);
+				}
+			}
+			await this.flushCompaction(id);
+		});
+	}
+	report(stage, id, error) {
+		this.knowledge.logger.warn(`Knowledge formation failed: stage=${stage} session=${id ?? "-"} code=${formationFault(error)}.`);
+	}
+	schedule(stage, id, action) {
+		this.pending = this.pending.then(action).then(() => void 0).catch((error) => {
+			this.report(stage, id, error);
+		});
+	}
+	async flushCompaction(id) {
+		const until = this.compactions.get(id);
+		if (until === void 0) return;
+		try {
+			await retryFormation(() => this.enqueueNew(id, "recap", "compaction", until));
+			this.compactions.delete(id);
+		} catch (error) {
+			this.report("enqueue", id, error);
+			throw new JobError("formation_enqueue", "复盘任务入队失败，投影已保留；请检查本地存储后再次复盘。");
+		}
+	}
+	async flush(id) {
+		const task = this.pending.then(async () => {
+			const ids = id === void 0 ? /* @__PURE__ */ new Set([
+				...await this.transcript.sessions(true),
+				...this.captures.ids(),
+				...this.compactions.keys()
+			]) : /* @__PURE__ */ new Set([id]);
+			let failure;
+			for (const current of ids) try {
+				await this.captures.prepare(current);
+				await this.flushCompaction(current);
+			} catch (error) {
+				failure ??= error instanceof Error ? error : new JobError("storage", "本地复盘准备失败，请检查存储后重试。");
+			}
+			if (failure !== void 0) throw failure;
+		});
+		this.pending = task.catch(() => {});
+		await task;
+	}
+	async rememberRoute(route) {
+		const context = this.knowledge.context();
+		await withFileLock(`${context.paths.lastRoute}.lock`, () => writeYamlAtomic(context.paths.lastRoute, route, RouteSchema, context.logger));
+	}
+	running(id) {
+		this.activeSessions.add(id);
+		const timer = this.timers.get(id);
+		if (timer !== void 0) clearTimeout(timer);
+		this.timers.delete(id);
+	}
+	idle(id) {
+		this.running(id);
+		this.activeSessions.delete(id);
+		if (!this.closing) this.schedule("scan", id, () => this.checkIdle(id, Date.now()));
+		const minutes = this.knowledge.config.formation.finalizeIdleMinutes;
+		if (this.closing || minutes === 0) return;
+		const deadline = Date.now() + minutes * 6e4;
+		const wait = () => {
+			const remaining = deadline - Date.now();
+			if (remaining > 0) {
+				const timer = setTimeout(wait, Math.min(remaining, 2147483647));
+				timer.unref();
+				this.timers.set(id, timer);
+			} else {
+				this.timers.delete(id);
+				this.schedule("enqueue", id, async () => {
+					await this.captures.prepare(id);
+					return this.enqueue(id, "finalize");
+				});
+			}
+		};
+		wait();
+	}
+	disposed(id) {
+		this.running(id);
+		this.attached.delete(id);
+		this.activeSessions.delete(id);
+		if (!this.closing && this.knowledge.config.formation.finalizeOnDispose) this.schedule("enqueue", id, async () => {
+			await this.captures.prepare(id);
+			return this.enqueue(id, "finalize");
+		});
+	}
+	async finalize(id) {
+		await this.flush(id);
+		return this.enqueue(id, "finalize");
+	}
+	async recap(id) {
+		await this.flush(id);
+		const state = await this.transcript.state(id);
+		const until = this.activeSessions.has(id) ? Math.max(processedThrough(state), ...state.completedTurns) : state.lastSeenSeq;
+		return this.enqueueNew(id, "recap", "manual", until);
+	}
+	async scan(now = Date.now()) {
+		await this.pending;
+		await this.scanPending(now);
+	}
+	async scanPending(now) {
+		if (this.closing) return;
+		await this.reconcilePendingArchives();
+		for (const id of /* @__PURE__ */ new Set([...await this.transcript.sessions(true), ...this.captures.ids()])) try {
+			await this.checkIdle(id, now);
+		} catch (error) {
+			this.report("scan", id, error);
+		}
+	}
+	async checkIdle(id, now) {
+		if (!this.started || this.closing || this.activeSessions.has(id)) return;
+		await this.captures.prepare(id);
+		await this.flushCompaction(id);
+		await this.finishArchive(id);
+		const state = await this.transcript.state(id);
+		const trigger = idleTrigger(this.knowledge.config.formation, state, await this.transcript.read(id), now);
+		if (trigger === void 0) return;
+		const config = this.knowledge.config.llm;
+		const route = config.provider && config.model ? {
+			provider: config.provider,
+			model: config.model
+		} : state.lastRoute;
+		if (route === void 0 || this.routeReady !== void 0 && !await this.routeReady(route)) return;
+		if (!this.activeSessions.has(id)) await this.enqueueNew(id, "recap", trigger);
+	}
+	async beginArchive(id, upper) {
+		await this.pending;
+		if (!this.attached.has(id) && !this.captures.ids().includes(id) && !(await this.transcript.sessions(true)).includes(id)) return null;
+		await this.flush(id);
+		return (await this.transcript.lifecycle(id, (current) => {
+			current.archiveIntent = current.autoPaused && current.archivedThroughSeq !== null ? current.archivedThroughSeq : Math.min(upper ?? current.lastSeenSeq, current.lastSeenSeq);
+		})).archiveIntent;
+	}
+	async cancelArchive(id) {
+		await this.transcript.lifecycle(id, (state) => {
+			state.archiveIntent = null;
+		});
+	}
+	async archived(id, upper) {
+		this.archiveChecks.set(id, true);
+		await this.recordArchive(id, upper);
+		await this.flush(id);
+		await this.finishArchive(id);
+	}
+	async recordArchive(id, upper) {
+		await this.transcript.lifecycle(id, (state) => {
+			if (!state.autoPaused) {
+				state.autoPaused = true;
+				state.archivedThroughSeq = upper;
+				state.archivePending = true;
+			}
+			state.archiveIntent = null;
+		});
+		this.archiveChecks.delete(id);
+	}
+	async reconcileArchives(archived) {
+		this.archiveView = new Set(archived);
+		await this.pending;
+		await this.reconcilePendingArchives();
+		if (this.started) await this.scanPending(Date.now());
+	}
+	async reconcilePendingArchives() {
+		if (this.archiveView !== void 0) try {
+			for (const id of await this.transcript.sessions(true)) this.archiveChecks.set(id, this.archiveView.has(id));
+			this.archiveView = void 0;
+		} catch (error) {
+			this.report("scan", void 0, error);
+			return;
+		}
+		for (const [id, archived] of this.archiveChecks) try {
+			const state = await this.transcript.state(id);
+			if (state.archiveIntent !== null) if (archived) await this.recordArchive(id, state.archiveIntent);
+			else await this.cancelArchive(id);
+			else if (archived && state.archivedThroughSeq === null) await this.recordArchive(id, state.lastSeenSeq);
+			this.archiveChecks.delete(id);
+		} catch (error) {
+			this.report("replay", id, error);
+		}
+	}
+	async finishArchive(id) {
+		const state = await this.transcript.state(id);
+		if (!state.archivePending || state.archivedThroughSeq === null) return;
+		await this.enqueueNew(id, "finalize", "archive", state.archivedThroughSeq);
+		await this.transcript.lifecycle(id, (current) => {
+			current.archivePending = false;
+		});
+	}
+	async enqueueNew(id, kind, trigger, requestedUntil) {
+		const state = await this.transcript.state(id);
+		if (state.archiveIntent !== null || state.autoPaused && trigger !== "archive" && trigger !== "manual") return null;
+		const untilSeq = Math.min(requestedUntil ?? state.lastSeenSeq, state.lastSeenSeq, state.autoPaused ? state.archivedThroughSeq ?? -1 : state.lastSeenSeq);
+		const cursor = processedThrough(state);
+		if (untilSeq <= cursor || !(await this.transcript.read(id)).some((entry) => entry.seq > cursor && entry.seq <= untilSeq && entry.text.trim() !== "")) return null;
+		const existing = (await this.worker.queue.list()).find((job) => job.sessionId === id && (job.kind === kind || kind === "recap" && job.kind === "finalize") && typeof job.payload["untilSeq"] === "number" && job.payload["untilSeq"] >= untilSeq && (job.state === "queued" || job.state === "running" || trigger.endsWith("-idle") && job.state === "failed"));
+		if (existing !== void 0) return existing;
+		return this.worker.enqueue(kind, {
+			untilSeq,
+			trigger
+		}, id);
+	}
+	async enqueue(id, kind, requestedUntil) {
+		const state = await this.transcript.state(id);
+		const untilSeq = Math.min(requestedUntil ?? state.lastSeenSeq, state.lastSeenSeq, state.archiveIntent ?? (state.autoPaused ? state.archivedThroughSeq ?? -1 : state.lastSeenSeq));
+		return this.worker.enqueue(kind, { untilSeq }, id);
+	}
+	async run(job, control) {
+		const id = job.sessionId;
+		const until = job.payload["untilSeq"];
+		if (id === void 0 || typeof until !== "number" || !Number.isSafeInteger(until)) throw new JobError("validation", "形成任务缺少合法会话或区间。");
+		await this.flush(id);
+		await new FormationStore(this.knowledge.context()).recover();
+		const state = await this.transcript.state(id);
+		const fromSeq = processedThrough(state);
+		const untilSeq = Math.min(until, state.lastSeenSeq, state.archiveIntent ?? (state.autoPaused ? state.archivedThroughSeq ?? -1 : state.lastSeenSeq));
+		if (untilSeq <= fromSeq) {
+			if (job.kind === "finalize" && untilSeq >= 0) await this.transcript.advance(id, "finalize", untilSeq);
+			return { skipped: "already_processed" };
+		}
+		const entries = (await this.transcript.read(id)).filter((entry) => entry.seq > fromSeq && entry.seq <= untilSeq);
+		if (entries.length === 0) throw new JobError("transcript", "待处理区间的会话投影缺失；已保留任务，请检查本地 transcript 后重试。");
+		const analysisClaims = (await this.knowledge.snapshot()).claims;
+		const configured = this.knowledge.config.llm;
+		const route = configured.provider && configured.model ? {
+			provider: configured.provider,
+			model: configured.model
+		} : state.lastRoute;
+		if (route === void 0) throw new JobError("route", "没有本会话的 request/header 路由。请先完成一次会话请求，或配置 llm.provider 和 llm.model，然后用 /acn-status retry 重试。");
+		const input = JSON.stringify({
+			instruction: "根据本段真实任务证据形成可复用知识；没有有价值的新增或更新时返回空数组。",
+			transcript_projection: {
+				complete_history: false,
+				from_seq_exclusive: fromSeq,
+				until_seq_inclusive: untilSeq,
+				excluded: [
+					"system_instructions",
+					"catalog_injection",
+					"compaction_replacement",
+					"reasoning",
+					"private_memory",
+					"run_code_wrapper"
+				],
+				tool_results: "complete_public_results",
+				legacy_tool_result_completeness: "unknown"
+			},
+			transcript: entries.map((entry) => ({
+				role: entry.type,
+				content: entry.text,
+				...entry.projection === void 0 ? {} : { projection: entry.projection }
+			})),
+			local_claims: analysisClaims.filter((claim) => claim.status !== "deprecated")
+		});
+		const prepared = await structuredCall({
+			backend: this.backend,
+			context: this.knowledge.context(),
+			config: configured,
+			route,
+			jobId: job.id,
+			system: this.render("session_recap.j2", {}),
+			input,
+			schema: RecapOutputSchema,
+			parse: (value) => prepareFormation(value, this.knowledge.context().agentId, analysisClaims, recapClaimIds(entries.map((entry) => entry.text))),
+			signal: control.signal
+		});
+		control.signal.throwIfAborted();
+		if (job.kind === "recap" && (await this.worker.queue.list()).some((candidate) => candidate.kind === "finalize" && candidate.sessionId === id && candidate.state === "queued")) throw new Preempted();
+		const task = entries.filter((entry) => entry.type === "user").map((entry) => entry.text).join("\n") || "本段会话知识复盘";
+		return this.knowledge.applyFormation({
+			sessionId: id,
+			jobId: job.id,
+			kind: job.kind === "recap" ? "recap" : "finalize",
+			fromSeq,
+			untilSeq,
+			analysisClaims,
+			prepared,
+			task
+		}, control);
+	}
+	close() {
+		this.closeTask ??= this.finishClose();
+		return this.closeTask;
+	}
+	async finishClose() {
+		this.closing = true;
+		if (this.scanner !== void 0) clearInterval(this.scanner);
+		for (const timer of this.timers.values()) clearTimeout(timer);
+		this.timers.clear();
+		try {
+			await this.pending;
+			if (this.knowledge.config.formation.finalizeOnDispose) for (const id of this.attached) try {
+				await this.captures.prepare(id);
+				await this.enqueue(id, "finalize");
+			} catch (error) {
+				this.report("enqueue", id, error);
+			}
+		} finally {
+			for (const unregister of this.unregister) unregister();
+			if (this.ownsWorker) await this.worker.close();
+		}
+	}
+};
+//#endregion
+export { AcnFormation as t };