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

package/lib/structured-C9byFuzm.js

@@ -0,0 +1,453 @@
+import { n as ClaimStatusSchema, r as ConfidenceSchema } from "./claim-DOAGe8ZK.js";
+import { t as KnowledgeError } from "./errors-Bp_2WXBr.js";
+import { _ as JobError, c as readYamlOr, d as removeFile, f as writeTextAtomic, n as withFileLock, w as hasCode } from "./lock-DbmlKOoX.js";
+import { n as VersionedDocumentSchema, t as SessionStateStore } from "./session-state-CYqUhC95.js";
+import { z } from "zod";
+import fs from "node:fs/promises";
+import { join } from "node:path";
+//#region src/formation/schema.ts
+const draft = {
+	id: z.string(),
+	name: z.string(),
+	statement: z.string(),
+	scope: z.string(),
+	confidence: ConfidenceSchema,
+	evidence_summary: z.string(),
+	source_claim_ids: z.array(z.string())
+};
+const RecapOutputSchema = z.strictObject({
+	new_claims: z.array(z.strictObject(draft)),
+	updated_claims: z.array(z.strictObject({
+		...draft,
+		status: ClaimStatusSchema
+	})),
+	used_claim_ids: z.array(z.string()),
+	new_disputes: z.array(z.strictObject({
+		id: z.string(),
+		name: z.string(),
+		claims: z.array(z.string()).min(2),
+		summary: z.string()
+	}))
+});
+var FormationValidationError = class extends Error {
+	kind = "formation_validation";
+};
+//#endregion
+//#region src/formation/transcript.ts
+const RouteSchema = z.strictObject({
+	provider: z.string().min(1),
+	model: z.string().min(1)
+});
+const seq = z.number().int().min(-1).max(Number.MAX_SAFE_INTEGER);
+const FormationStateSchema = z.object({
+	lastSeenSeq: seq.default(-1),
+	recappedThroughSeq: seq.default(-1),
+	finalizedThroughSeq: seq.default(-1),
+	lastRoute: RouteSchema.optional(),
+	seenSourceIds: z.array(z.string()).default([]),
+	privateToolCalls: z.array(z.string()).default([]),
+	activityAt: z.number().int().nonnegative().default(0),
+	activitySeq: seq.default(-1),
+	humanTurn: z.boolean().default(false),
+	completedTurns: z.array(seq).default([]),
+	autoPaused: z.boolean().default(false),
+	archivedThroughSeq: seq.nullable().default(null),
+	archiveIntent: seq.nullable().default(null),
+	archivePending: z.boolean().default(false)
+});
+const TranscriptEntrySchema = z.strictObject({
+	seq: seq.refine((value) => value >= 0),
+	type: z.enum([
+		"user",
+		"assistant",
+		"tool_call",
+		"tool_result"
+	]),
+	text: z.string(),
+	projection: z.strictObject({
+		truncated: z.boolean(),
+		original_chars: z.number().int().nonnegative(),
+		retained_chars: z.number().int().nonnegative()
+	}).optional()
+});
+const processedThrough = (state) => Math.max(state.recappedThroughSeq, state.finalizedThroughSeq);
+var TranscriptStore = class {
+	context;
+	maxBytes;
+	states;
+	constructor(context, maxBytes = 50 * 1024 * 1024) {
+		this.context = context;
+		this.maxBytes = maxBytes;
+		this.states = new SessionStateStore(context);
+	}
+	async state(id) {
+		return FormationStateSchema.parse(await this.states.read(id) ?? {});
+	}
+	async read(id, repair = false) {
+		let text = "";
+		try {
+			text = await fs.readFile(this.context.paths.transcript(id), "utf8");
+		} catch (error) {
+			if (!hasCode(error, "ENOENT")) throw error;
+		}
+		const complete = text.slice(0, text.lastIndexOf("\n") + 1);
+		const entries = complete.split("\n").filter(Boolean).map((line) => {
+			try {
+				return TranscriptEntrySchema.parse(JSON.parse(line));
+			} catch {
+				throw new JobError("transcript", "会话投影存在损坏的完整行；请检查本地 transcript 文件后重试。");
+			}
+		});
+		for (let index = 1; index < entries.length; index += 1) {
+			const previous = entries[index - 1];
+			const current = entries[index];
+			if (previous !== void 0 && current !== void 0 && current.seq <= previous.seq) throw new JobError("transcript", "会话投影的 seq 顺序损坏；请检查本地 transcript 后重试。");
+		}
+		if (repair && complete !== text) {
+			await writeTextAtomic(this.context.paths.transcript(id), complete, this.context.logger);
+			this.context.logger.warn("Repaired incomplete transcript tail.");
+		}
+		for (const file of await this.pendingFiles(id)) {
+			const body = await fs.readFile(join(this.context.paths.transcriptPending(id), file), "utf8");
+			let entry;
+			try {
+				entry = TranscriptEntrySchema.parse(JSON.parse(body));
+			} catch {
+				throw new JobError("transcript", "会话投影分片损坏；请检查本地 transcript-pending 后重试。");
+			}
+			if (`${entry.seq}.json` !== file) throw new JobError("transcript", "会话投影分片 seq 与文件名不一致。");
+			entries.push(entry);
+		}
+		const unique = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const previous = unique.get(entry.seq);
+			if (previous !== void 0 && JSON.stringify(previous) !== JSON.stringify(entry)) throw new JobError("transcript", "同一 seq 的会话投影内容冲突。");
+			unique.set(entry.seq, entry);
+		}
+		return [...unique.values()].sort((a, b) => a.seq - b.seq);
+	}
+	async pendingFiles(id) {
+		try {
+			return (await fs.readdir(this.context.paths.transcriptPending(id))).filter((file) => /^(0|[1-9][0-9]*)\.json$/.test(file));
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return [];
+			throw error;
+		}
+	}
+	async materialize(id, entries) {
+		let main = "";
+		let bytes = 0;
+		const spill = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			const line = `${JSON.stringify(entry)}\n`;
+			const size = Buffer.byteLength(line);
+			if (size > this.maxBytes) throw new JobError("transcript_limit", "单条会话投影超过 50MB；请缩小单次输入后重试。");
+			if (bytes + size <= this.maxBytes) {
+				main += line;
+				bytes += size;
+			} else {
+				const file = `${entry.seq}.json`;
+				spill.add(file);
+				await writeTextAtomic(join(this.context.paths.transcriptPending(id), file), line, this.context.logger);
+			}
+		}
+		await writeTextAtomic(this.context.paths.transcript(id), main, this.context.logger);
+		for (const file of await this.pendingFiles(id)) if (!spill.has(file)) await removeFile(join(this.context.paths.transcriptPending(id), file), this.context.logger);
+		return bytes;
+	}
+	async record(id, projection) {
+		await this.states.update(id, async (current) => {
+			const state = FormationStateSchema.parse(current ?? {});
+			const entries = await this.read(id, true);
+			const tail = entries.at(-1)?.seq ?? -1;
+			state.lastSeenSeq = Math.max(state.lastSeenSeq, tail);
+			if (projection.route !== void 0) state.lastRoute = projection.route;
+			if (projection.privateCallId !== void 0 && !state.privateToolCalls.includes(projection.privateCallId)) state.privateToolCalls.push(projection.privateCallId);
+			const privateResult = projection.resultCallId !== void 0 && state.privateToolCalls.includes(projection.resultCallId);
+			if (!privateResult) state.seenSourceIds = [.../* @__PURE__ */ new Set([...state.seenSourceIds, ...projection.seenSourceIds ?? []])];
+			const entry = projection.entry;
+			if (!privateResult && entry !== void 0 && entry.seq > state.lastSeenSeq) {
+				const line = `${JSON.stringify(entry)}\n`;
+				if (Buffer.byteLength(line) > this.maxBytes) throw new JobError("transcript_limit", "单条会话投影超过 50MB；请缩小单次输入后重试。");
+				let bytes = 0;
+				try {
+					bytes = (await fs.stat(this.context.paths.transcript(id))).size;
+				} catch (error) {
+					if (!hasCode(error, "ENOENT")) throw error;
+				}
+				if (bytes + Buffer.byteLength(line) > this.maxBytes) bytes = await this.materialize(id, entries.filter((row) => row.seq > processedThrough(state)));
+				if (bytes + Buffer.byteLength(line) > this.maxBytes) await writeTextAtomic(join(this.context.paths.transcriptPending(id), `${entry.seq}.json`), line, this.context.logger);
+				else {
+					const file = await fs.open(this.context.paths.transcript(id), "a", 384);
+					try {
+						await file.writeFile(line);
+						await file.sync();
+					} finally {
+						await file.close();
+					}
+				}
+				state.lastSeenSeq = entry.seq;
+			}
+			const activity = projection.activity;
+			if (!privateResult && activity !== void 0 && activity.seq > state.activitySeq) {
+				state.activitySeq = activity.seq;
+				if (activity.turn === "start") state.humanTurn = false;
+				if (activity.human) {
+					state.humanTurn = true;
+					if (state.archiveIntent === null) state.autoPaused = false;
+				}
+				if (!state.autoPaused && state.archiveIntent === null) state.activityAt = Math.max(state.activityAt, activity.at);
+				if (activity.turn === "completed" && state.humanTurn && state.lastSeenSeq > processedThrough(state)) state.completedTurns.push(state.lastSeenSeq);
+				if (activity.turn === "completed" || activity.turn === "ended") state.humanTurn = false;
+			}
+			if (state.activityAt === 0 && state.lastSeenSeq >= 0) state.activityAt = Date.now();
+			return VersionedDocumentSchema.parse({
+				...current,
+				schemaVersion: 1,
+				...state
+			});
+		});
+	}
+	async replay(id, projections) {
+		await this.states.update(id, async (current) => {
+			const state = FormationStateSchema.parse(current ?? {});
+			const entries = new Map((await this.read(id, true)).map((entry) => [entry.seq, entry]));
+			const coveredThrough = projections.reduce((upper, projection) => Math.max(upper, projection.sourceSeq ?? -1, projection.entry?.seq ?? -1, projection.activity?.seq ?? -1), -1);
+			const unarchived = projections.some((projection) => projection.sourceArchived === false);
+			let resumedAt;
+			if ([...entries.values()].some((entry) => entry.seq > processedThrough(state) && entry.seq > coveredThrough)) throw new JobError("transcript_source", "Original session log does not cover the retained projection.");
+			state.privateToolCalls = [.../* @__PURE__ */ new Set([...state.privateToolCalls, ...projections.flatMap((projection) => projection.privateCallId === void 0 ? [] : [projection.privateCallId])])];
+			for (const projection of projections) {
+				if (projection.route !== void 0) state.lastRoute = projection.route;
+				if (projection.resultCallId !== void 0 && state.privateToolCalls.includes(projection.resultCallId)) {
+					if (projection.entry !== void 0) entries.delete(projection.entry.seq);
+					continue;
+				}
+				state.seenSourceIds = [.../* @__PURE__ */ new Set([...state.seenSourceIds, ...projection.seenSourceIds ?? []])];
+				const entry = projection.entry;
+				if (entry !== void 0 && entry.seq > processedThrough(state)) {
+					const previous = entries.get(entry.seq);
+					if (previous !== void 0 && JSON.stringify(previous) !== JSON.stringify(entry)) throw new JobError("transcript", "原会话与已有投影内容冲突；未覆盖已有数据。");
+					entries.set(entry.seq, entry);
+					state.lastSeenSeq = Math.max(state.lastSeenSeq, entry.seq);
+				}
+				const activity = projection.activity;
+				if (activity?.human && unarchived && state.autoPaused && state.archiveIntent === null && state.archivedThroughSeq !== null && activity.seq > state.archivedThroughSeq) {
+					state.autoPaused = false;
+					resumedAt = activity.seq;
+				}
+				if (activity !== void 0 && resumedAt !== void 0 && activity.seq >= resumedAt) state.activityAt = Math.max(state.activityAt, activity.at);
+				if (activity !== void 0 && activity.seq > state.activitySeq) {
+					state.activitySeq = activity.seq;
+					if (activity.turn === "start") state.humanTurn = false;
+					if (activity.human) state.humanTurn = true;
+					if (!state.autoPaused && state.archiveIntent === null) state.activityAt = Math.max(state.activityAt, activity.at);
+					if (activity.turn === "completed" && state.humanTurn && state.lastSeenSeq > processedThrough(state)) state.completedTurns.push(state.lastSeenSeq);
+					if (activity.turn === "completed" || activity.turn === "ended") state.humanTurn = false;
+				}
+			}
+			const sorted = [...entries.values()].sort((left, right) => left.seq - right.seq);
+			await this.materialize(id, sorted);
+			state.lastSeenSeq = Math.max(state.lastSeenSeq, sorted.at(-1)?.seq ?? -1);
+			return VersionedDocumentSchema.parse({
+				...current,
+				schemaVersion: 1,
+				...state
+			});
+		});
+	}
+	async advance(id, kind, untilSeq) {
+		await this.states.update(id, async (current) => {
+			const state = FormationStateSchema.parse(current ?? {});
+			state.recappedThroughSeq = Math.max(state.recappedThroughSeq, untilSeq);
+			state.lastSeenSeq = Math.max(state.lastSeenSeq, untilSeq);
+			if (kind === "finalize") state.finalizedThroughSeq = Math.max(state.finalizedThroughSeq, untilSeq);
+			state.completedTurns = state.completedTurns.filter((end) => end > processedThrough(state));
+			const remaining = (await this.read(id, true)).filter((entry) => entry.seq > processedThrough(state));
+			await this.materialize(id, remaining);
+			return VersionedDocumentSchema.parse({
+				...current,
+				schemaVersion: 1,
+				...state
+			});
+		});
+	}
+	async lifecycle(id, change) {
+		return FormationStateSchema.parse(await this.states.update(id, (current) => {
+			const state = FormationStateSchema.parse(current ?? {});
+			change(state);
+			return VersionedDocumentSchema.parse({
+				...current,
+				schemaVersion: 1,
+				...state
+			});
+		}));
+	}
+	async sessions(formationOnly = false) {
+		let entries;
+		try {
+			entries = await fs.readdir(this.context.paths.sessions, { withFileTypes: true });
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return [];
+			throw error;
+		}
+		const ids = [];
+		for (const entry of entries) {
+			if (!entry.isDirectory() || !/^[a-zA-Z0-9_-]+$/.test(entry.name)) continue;
+			if (!formationOnly) {
+				ids.push(entry.name);
+				continue;
+			}
+			try {
+				const files = await fs.readdir(this.context.paths.session(entry.name));
+				if (files.includes("transcript.jsonl") || files.includes("transcript-pending")) {
+					ids.push(entry.name);
+					continue;
+				}
+				const state = await this.states.read(entry.name);
+				if (state !== null && Object.hasOwn(state, "lastSeenSeq")) ids.push(entry.name);
+			} catch {
+				ids.push(entry.name);
+			}
+		}
+		return ids;
+	}
+};
+//#endregion
+//#region src/llm/structured.ts
+const invalidLabels = {
+	json_syntax: "JSON 语法",
+	schema: "字段结构",
+	reference: "引用或领域约束",
+	incomplete: "输出未完整结束",
+	output_limit: "输出 token 上限（MAX_TOKENS）",
+	non_text: "缺少 JSON 文本或返回了工具调用、附件"
+};
+function abortable(promise, signal) {
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			const reason = signal.reason;
+			reject(reason instanceof Error ? reason : new JobError("aborted", "后台调用已取消。"));
+		};
+		signal.addEventListener("abort", abort, { once: true });
+		if (signal.aborted) abort();
+		promise.then(resolve, reject).finally(() => {
+			signal.removeEventListener("abort", abort);
+		});
+	});
+}
+async function resolveRoute(config, context, sessionRoute) {
+	if (config.provider && config.model) return {
+		provider: config.provider,
+		model: config.model
+	};
+	if (sessionRoute !== void 0) return sessionRoute;
+	const route = await readYamlOr(context.paths.lastRoute, RouteSchema, () => null);
+	if (route === null) throw new JobError("route", "没有可用的模型路由。请先完成一次会话请求，或配置 llm.provider 和 llm.model 后重试任务。");
+	return route;
+}
+function transportError(error) {
+	if (error instanceof JobError) return error;
+	const record = typeof error === "object" && error !== null ? error : {};
+	const code = "code" in record && typeof record.code === "string" ? record.code : "";
+	const status = "status" in record && typeof record.status === "number" ? record.status : 0;
+	const delay = "providerRetryAfterMs" in record ? record.providerRetryAfterMs : void 0;
+	const retryAfterMs = typeof delay === "number" && Number.isFinite(delay) && delay > 0 && delay <= 2147483647 ? Math.ceil(delay) : void 0;
+	const retry = (kind, message) => new JobError(kind, message + (retryAfterMs === void 0 ? "" : ` 提供商要求至少等待 ${Math.ceil(retryAfterMs / 1e3)} 秒。`), true, retryAfterMs);
+	if (code === "CONTEXT_WINDOW_EXCEEDED") return new JobError("context_limit", "后台模型输入超过上下文容量（CONTEXT_WINDOW_EXCEEDED）；请配置更大上下文的模型后重试任务。");
+	if (/^(?:AUTH|AUTH_FAILED|INVALID_CREDENTIAL|MISSING_CREDENTIAL)$/.test(code) || status === 401 || status === 403) return new JobError("model_auth", "后台模型鉴权失败（AUTH）；请在 DSH 模型设置中检查提供商的凭据配置后重试。");
+	if (code === "QUOTA" || code === "ACCOUNT_QUOTA" || status === 402) return new JobError("model_quota", "后台模型额度不足（QUOTA）；请检查提供商额度或更换知识处理模型后重试。");
+	if (code === "MALFORMED_RESPONSE") return new JobError("model_response", "后台模型返回的响应格式无效（MALFORMED_RESPONSE）；可稍后重试或更换知识处理模型。");
+	if (code === "NO_ADAPTER") return new JobError("route", "后台模型适配器不可用（NO_ADAPTER）；请检查 DSH 中的提供商与知识处理模型配置。");
+	if (code === "INVALID_REQUEST" || status === 400 || status === 413) return new JobError("model_request", "后台模型拒绝请求（INVALID_REQUEST）；请检查所选模型支持的参数和上下文、输出上限。");
+	if (code === "EMPTY_RESPONSE") return retry("model_empty", "后台模型返回空响应（EMPTY_RESPONSE）；可稍后重试或更换知识处理模型。");
+	if (code === "RATE_LIMIT" || code === "RATE_LIMITED" || status === 429) return retry("model_rate_limit", "后台模型请求受限（RATE_LIMIT）；请稍后重试或检查提供商并发限制。");
+	if (code === "TIMEOUT" || code === "ETIMEDOUT" || code === "HTTP_408" || status === 408) return retry("timeout", "后台模型调用超时（TIMEOUT）；请检查网络和模型服务，或调整超时后重试。");
+	if (code === "SERVER" || code === "SERVER_ERROR" || status >= 500 && status <= 599) return retry("model_server", "后台模型服务暂时不可用（SERVER）；请稍后重试或更换知识处理模型。");
+	if (/^(?:NETWORK|TRANSPORT|NETWORK_ERROR|CONNECTION_ERROR|ECONNRESET|ECONNREFUSED)$/.test(code)) return retry("transport", "后台模型网络连接失败（TRANSPORT）；请检查网络和模型服务后重试。");
+	return new JobError("route", "后台模型调用不可用。请检查 llm.provider、llm.model、适配器及凭据配置后重试任务。");
+}
+async function structuredCall(options) {
+	const { backend, context, config, route, jobId, signal } = options;
+	let feedback = "";
+	let lastInvalid;
+	for (let attempt = 1; attempt <= config.structuredRetries; attempt += 1) {
+		signal.throwIfAborted();
+		for (let transport = 1; transport <= 3; transport += 1) {
+			signal.throwIfAborted();
+			let response;
+			const startedAt = Date.now();
+			const timeout = AbortSignal.timeout(config.timeoutMs);
+			const callSignal = AbortSignal.any([signal, timeout]);
+			let outcome = "transport_failed";
+			let invalid;
+			try {
+				const schema = JSON.stringify(z.toJSONSchema(options.schema));
+				try {
+					response = await abortable(backend(route, `${options.system}\n只输出一个 JSON 对象，不调用工具。必须符合此 JSON schema：\n${schema}${feedback}`, options.input, config.maxOutputTokens, callSignal), callSignal);
+				} catch (error) {
+					signal.throwIfAborted();
+					if (error instanceof JobError && [
+						"structured_output",
+						"structured_output_limit",
+						"structured_output_content"
+					].includes(error.kind)) {
+						outcome = "invalid";
+						lastInvalid = error.kind === "structured_output_limit" ? "output_limit" : error.kind === "structured_output_content" ? "non_text" : "incomplete";
+						invalid = { kind: lastInvalid };
+						feedback = `\n上次响应未通过校验：${error.message}\n请重新提交完整 JSON 对象。`;
+						break;
+					}
+					const failure = timeout.aborted ? transportError({ code: "TIMEOUT" }) : transportError(error);
+					if (!failure.retryable || transport === 3 || failure.retryAfterMs !== void 0) throw failure;
+					continue;
+				}
+				try {
+					const text = response.text.trim().replace(/^```(?:json)?\s*\n?([\s\S]*?)\n?```$/i, "$1");
+					const value = JSON.parse(text);
+					const result = options.parse(options.schema.parse(value));
+					outcome = "succeeded";
+					return result;
+				} catch (error) {
+					if (!(error instanceof SyntaxError || error instanceof z.ZodError || error instanceof FormationValidationError || error instanceof KnowledgeError)) throw error;
+					const summary = error instanceof z.ZodError ? error.issues.slice(0, 8).map((issue) => `${issue.path.join(".") || "$"}: ${issue.code}${issue.code === "unrecognized_keys" ? `；删除多余字段 ${JSON.stringify(issue.keys.slice(0, 8)).slice(0, 400)}` : ""}`).join("; ") : error instanceof FormationValidationError || error instanceof KnowledgeError ? error.message : "JSON 解析失败：检查字段名后的冒号、逗号、引号和转义；不要输出注释或省略号。";
+					lastInvalid = error instanceof z.ZodError ? "schema" : error instanceof SyntaxError ? "json_syntax" : "reference";
+					invalid = {
+						kind: lastInvalid,
+						...error instanceof z.ZodError ? { issueCodes: [...new Set(error.issues.map((issue) => issue.code))] } : {}
+					};
+					outcome = "invalid";
+					feedback = `\n上次响应未通过校验：${summary}\n请重新提交完整 JSON 对象。`;
+					break;
+				}
+			} finally {
+				const day = new Date(startedAt).toISOString().slice(0, 10);
+				const path = join(context.paths.llmCalls, `${day}.jsonl`);
+				await withFileLock(`${path}.lock`, async () => {
+					await fs.mkdir(context.paths.llmCalls, { recursive: true });
+					const file = await fs.open(path, "a", 384);
+					try {
+						await file.writeFile(`${JSON.stringify({
+							jobId,
+							route,
+							...options.phase === void 0 ? {} : { phase: options.phase },
+							attempt,
+							transport,
+							startedAt,
+							elapsedMs: Date.now() - startedAt,
+							outcome,
+							...invalid === void 0 ? {} : { invalid },
+							...response?.usage === void 0 ? {} : { usage: response.usage }
+						})}\n`);
+						await file.sync();
+					} finally {
+						await file.close();
+					}
+				});
+			}
+		}
+	}
+	throw new JobError("structured_output", `${options.phase === void 0 ? "" : `${options.phase} 阶段：`}连续 ${config.structuredRetries} 次响应未通过结构或引用校验${lastInvalid === void 0 ? "" : `（最后失败：${invalidLabels[lastInvalid]}）`}；请检查模型后使用 /acn-status retry 重试任务。`);
+}
+//#endregion
+export { FormationStateSchema as a, TranscriptStore as c, RecapOutputSchema as d, transportError as i, processedThrough as l, resolveRoute as n, RouteSchema as o, structuredCall as r, TranscriptEntrySchema as s, abortable as t, FormationValidationError as u };

package/lib/subagent-yJsFxHmH.js

@@ -0,0 +1,9 @@
+//#region src/tools/subagent.ts
+function isSubagent(header) {
+	return header.origin === "subagent" || (header.delegationDepth ?? 0) > 0;
+}
+function isEvidenceAgent(header) {
+	return header.origin === "subagent" && (header.agentPreset === "acn-evidence" || header.agentPreset === "acn-dream");
+}
+//#endregion
+export { isSubagent as n, isEvidenceAgent as t };

package/lib/team.js

@@ -0,0 +1,3 @@
+import { t as TeamError } from "./errors-pPumDOGD.js";
+import { a as bypassProxy, i as TeamHttp, n as MaintainerClient, o as teamUrl, r as RouterClient, t as TeamFacade } from "./service-BQaszW_v.js";
+export { MaintainerClient, RouterClient, TeamError, TeamFacade, TeamHttp, bypassProxy, teamUrl };

package/lib/tool-schema-3b4gH1zf.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+//#region src/dsh-adapter/tool-schema.ts
+const JsonObject = z.record(z.string(), z.json());
+function toolParameters(schema) {
+	const root = JsonObject.parse(JSON.parse(JSON.stringify(z.toJSONSchema(schema))));
+	if (!Array.isArray(root.oneOf)) return root;
+	const variants = root.oneOf.map((value) => JsonObject.parse(value));
+	const fields = variants.map((variant) => JsonObject.parse(variant.properties));
+	const keys = [...new Set(fields.flatMap((field) => Object.keys(field)))];
+	const properties = Object.fromEntries(keys.map((key) => {
+		const distinct = [...new Map(fields.filter((field) => field[key] !== void 0).map((field) => [JSON.stringify(field[key]), JsonObject.parse(field[key])])).values()];
+		const values = distinct.map((field) => field.const);
+		return [key, distinct.length === 1 ? distinct[0] : values.every((value) => typeof value === "string") ? {
+			type: "string",
+			enum: values
+		} : { anyOf: distinct }];
+	}));
+	const requiredSets = variants.map((variant) => z.array(z.string()).parse(variant.required ?? []));
+	const required = (requiredSets[0] ?? []).filter((key) => requiredSets.every((set) => set.includes(key)));
+	return JsonObject.parse({
+		...root,
+		type: "object",
+		properties,
+		required
+	});
+}
+//#endregion
+export { toolParameters as t };

package/lib/trace-Da0RnL5R.js

@@ -0,0 +1,14 @@
+import { a as TextSchema, c as AgentIdSchema, h as TraceIdSchema, l as ClaimIdSchema, m as SourceIdSchema, y as TimestampSchema } from "./claim-DOAGe8ZK.js";
+import { z } from "zod";
+//#region src/protocol/trace.ts
+const TraceSchema = z.object({
+	id: TraceIdSchema,
+	name: TextSchema,
+	task: TextSchema,
+	agent: AgentIdSchema,
+	input_claims: z.array(SourceIdSchema).default([]),
+	output_claims: z.array(ClaimIdSchema).default([]),
+	created_at: TimestampSchema
+});
+//#endregion
+export { TraceSchema as t };

package/lib/traces-CHBo8y1z.js

@@ -0,0 +1,11 @@
+import { h as TraceIdSchema } from "./claim-DOAGe8ZK.js";
+import { a as EntityStore } from "./reported-sets-DdEKdeVb.js";
+import { t as TraceSchema } from "./trace-Da0RnL5R.js";
+//#region src/store/traces.ts
+var TraceStore = class extends EntityStore {
+	constructor(context) {
+		super(context, context.paths.traces, TraceSchema, TraceIdSchema);
+	}
+};
+//#endregion
+export { TraceStore as t };

package/lib/types/activities.d.ts

@@ -0,0 +1,73 @@
+import type { AcnKnowledge } from './knowledge/service.js';
+import type { JobKind } from './worker/types.js';
+import type { Activity } from './interaction.js';
+import { z } from 'zod';
+export declare function activityDetails(result: unknown): {
+    counts: {
+        [k: string]: number;
+    };
+    entityIds: ((string & z.core.$brand<"ClaimId">) | (string & z.core.$brand<"TraceId">) | (string & z.core.$brand<"DisputeId">))[];
+    summary: string;
+    warnings: string[];
+    incompleteCandidates: {
+        groupId: string;
+        claimIds: (string & z.core.$brand<"ClaimId">)[];
+        reason: string;
+    }[];
+    budgetLimited: boolean;
+};
+export declare function emptyInbox(result: unknown): boolean;
+export declare function allActivities(knowledge: AcnKnowledge, supports?: (kind: JobKind) => boolean): Promise<Activity[]>;
+export interface ActivityPage {
+    attentionOnly?: boolean;
+    sourceSession?: string;
+    kind?: string;
+    state?: string;
+    offset?: number;
+}
+export declare function activityPage(rows: Activity[], options?: ActivityPage): {
+    activities: {
+        id: string;
+        kind: string;
+        state: string;
+        attempts: number;
+        updatedAt: number;
+        unseen: boolean;
+        summary: string;
+        sessionId?: string | undefined;
+        source?: {
+            id: string;
+            available: boolean;
+            title?: string | undefined;
+        } | undefined;
+        error?: string | undefined;
+        summaryInfo?: {
+            code: string;
+            count?: number | undefined;
+            entityId?: string | undefined;
+            status?: number | undefined;
+        } | undefined;
+        errorInfo?: {
+            code: string;
+            count?: number | undefined;
+            entityId?: string | undefined;
+            status?: number | undefined;
+        } | undefined;
+        counts?: Record<string, number> | undefined;
+        warnings?: string[] | undefined;
+        budgetLimited?: boolean | undefined;
+        requiresAttention?: boolean | undefined;
+        incompleteCandidates?: {
+            groupId: string;
+            claimIds: (string & z.core.$brand<"ClaimId">)[];
+            reason: string;
+        }[] | undefined;
+        entityIds?: ((string & z.core.$brand<"ClaimId">) | (string & z.core.$brand<"TraceId">) | (string & z.core.$brand<"DisputeId">))[] | undefined;
+        entityId?: string | undefined;
+        retryable?: boolean | undefined;
+        acknowledged?: boolean | undefined;
+        reportPath?: string | undefined;
+        phase?: "finished" | "wrap_up" | "exploration" | undefined;
+    }[];
+    activitiesOmitted: number;
+};

package/lib/types/advanced-configuration.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const AdvancedConfigurationSchema: z.ZodObject<{
+    inboxProcessingStaleAfterSecs: z.ZodNumber;
+    routerQueryTimeoutSecs: z.ZodNumber;
+    httpTimeoutSecs: z.ZodNumber;
+    httpRetryCount: z.ZodNumber;
+    httpRetryBaseDelayMs: z.ZodNumber;
+    httpRetryMaxDelayMs: z.ZodNumber;
+}, z.core.$strict>;
+export type AdvancedConfiguration = z.infer<typeof AdvancedConfigurationSchema>;
+export declare function advancedConfiguration(raw: unknown): AdvancedConfiguration;

package/lib/types/client/ActivityCard.d.ts

@@ -0,0 +1,14 @@
+import type { Activity, InteractionRequest } from '../interaction.js';
+import type { InteractionApi } from './TeamSettingsPage.js';
+import type { Copy } from './interaction-ui.js';
+export declare function ActivityCard(props: {
+    item: Activity;
+    runtimeKey: string;
+    busy: boolean;
+    c: Copy;
+    api: InteractionApi;
+    action: (request: InteractionRequest) => void;
+    openSource?: ((id: string) => void) | undefined;
+    openClaim: (id: string, from: string) => void;
+    openComponents?: (() => void) | undefined;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/types/client/ActivityDetails.d.ts

@@ -0,0 +1,18 @@
+import type { InteractionApi } from './TeamSettingsPage.js';
+import type { Activity, InteractionRequest } from '../interaction.js';
+import type { Copy } from './interaction-ui.js';
+export declare function activityKind(kind: string, c: Copy): string;
+export declare function activityState(item: Activity, c: Copy): string;
+export declare function activitySummary(item: Activity, c: Copy): string;
+export declare function ActivityDetails({ item, runtimeKey, busy, c, showSummary, action, openClaim, openComponents }: {
+    item: Activity;
+    runtimeKey: string;
+    busy: boolean;
+    c: Copy;
+    api: InteractionApi;
+    showSummary?: boolean;
+    action: (request: InteractionRequest) => void;
+    openSource?: ((id: string) => void) | undefined;
+    openClaim: (id: string, from: string) => void;
+    openComponents?: (() => void) | undefined;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/types/client/AdvancedPreferences.d.ts

@@ -0,0 +1,8 @@
+import type { AdvancedConfiguration } from '../advanced-configuration.js';
+import type { Copy } from './interaction-ui.js';
+export declare function AdvancedPreferences({ value, busy, c, save }: {
+    value: AdvancedConfiguration;
+    busy: boolean;
+    c: Copy;
+    save: (value: AdvancedConfiguration) => Promise<boolean>;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/types/client/BlankCommandFeedback.d.ts

@@ -0,0 +1,10 @@
+import type { CommandResult } from '@deepseek-ai/dsh-commands';
+import type { Copy } from './interaction-ui.js';
+type Listener = (sessionId: string, name: string, result: CommandResult) => void;
+export declare function BlankCommandFeedback({ sessionId, blank, subscribe, c }: {
+    sessionId: string;
+    blank: boolean;
+    subscribe: (listener: Listener) => () => void;
+    c: Copy;
+}): import("react/jsx-runtime").JSX.Element | null;
+export {};