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

package/lib/team-credentials-C9xHrPIi.js

@@ -0,0 +1,579 @@
+import { S as timestampNanos, c as AgentIdSchema, i as effectiveUpdatedAt, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { R as nextClaimUpdateAt } from "./evidence-store-DLFvSuNa.js";
+import { n as claimRevision } from "./revision-DeoL_IUN.js";
+import { n as RevisionConflict, t as KnowledgeError } from "./errors-Bp_2WXBr.js";
+import { n as validateClaimText } from "./regular-file-BFpqMoub.js";
+import { C as StoreError, S as LockTimeoutError, d as removeFile, n as withFileLock, u as cleanupAtomicTemps, w as hasCode } from "./lock-DbmlKOoX.js";
+import { n as AnalysisReadBoundary, r as KnowledgeBusy } from "./alignment-CwH0nBf-.js";
+import { i as ClaimStore } from "./reported-sets-DdEKdeVb.js";
+import { t as TraceStore } from "./traces-CHBo8y1z.js";
+import { r as UploadStore } from "./uploads-BCA2p92b.js";
+import { t as DreamStore } from "./checkpoint-RgcdqifN.js";
+import { a as assertStorageName, n as agentHomePath, t as AgentPaths } from "./paths-CDYV5UH9.js";
+import { n as ClaimEditStore } from "./disputes-ByEmi43j.js";
+import { n as FormationStore } from "./checkpoint-Bmt8q2vB.js";
+import { n as InboxEffectStore } from "./effects-DJ4Xa7Tx.js";
+import { t as TeamFacade } from "./service-B7AI5jds.js";
+import { t as DurableWorker } from "./worker-BBTYP2RE.js";
+import { r as MAX_TRACE_TASK_PAGE_LIMIT, t as ClaimUpdateSchema } from "./types-C2ST2Zdg.js";
+import { a as validatePage, n as claimListPage, r as page } from "./pages-BEWC3kmZ.js";
+import { t as PresentationStore } from "./presentation-BlLjgDjP.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import fs, { realpath } from "node:fs/promises";
+import { join, resolve } from "node:path";
+//#region src/config.ts
+const positive = () => z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const nonnegative = () => z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const endpoint = z.string().refine((value) => {
+	if (value === "") return true;
+	try {
+		const url = new URL(value);
+		return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash;
+	} catch {
+		return false;
+	}
+});
+const UpstreamNameSchema = z.string().regex(/^[a-z0-9_-]+$/).refine((value) => ![
+	"data",
+	"skills",
+	"config.toml",
+	"acn.md",
+	"logs",
+	"tmp",
+	".git"
+].includes(value));
+const UpstreamSchema = z.strictObject({
+	name: z.string().trim().max(80).default(""),
+	agentId: AgentIdSchema,
+	enabled: z.boolean().default(true),
+	routerEndpoint: endpoint.default(""),
+	maintainerEndpoint: endpoint.default(""),
+	keyEnv: z.string().regex(/^(?:[A-Za-z_][A-Za-z0-9_]*)?$/).default(""),
+	timeoutMs: positive().default(15e3),
+	legacyStorage: z.enum([
+		"base",
+		"personal",
+		"connection"
+	]).optional(),
+	legacyKey: z.string().regex(/^[a-zA-Z0-9_-]{1,80}$/).optional()
+}).superRefine((value, ctx) => {
+	if (Boolean(value.routerEndpoint) !== Boolean(value.maintainerEndpoint)) ctx.addIssue({
+		code: "custom",
+		path: ["routerEndpoint"],
+		message: "Configure both team endpoints or neither."
+	});
+	if (value.legacyStorage === "connection" !== (value.legacyKey !== void 0)) ctx.addIssue({
+		code: "custom",
+		path: ["legacyStorage"],
+		message: "Invalid legacy storage mapping."
+	});
+});
+const ConnectionSchema = z.strictObject({
+	id: z.string().regex(/^[a-zA-Z0-9_-]{1,80}$/).refine((id) => !["personal", "legacy"].includes(id)),
+	name: z.string().trim().min(1).max(80),
+	enabled: z.boolean().default(true),
+	agentId: AgentIdSchema,
+	routerEndpoint: endpoint.refine(Boolean),
+	maintainerEndpoint: endpoint.refine(Boolean),
+	keyEnv: z.string().regex(/^(?:[A-Za-z_][A-Za-z0-9_]*)?$/).default(""),
+	timeoutMs: positive().default(15e3)
+});
+const ConfigSchema = z.strictObject({
+	upstream: z.string().default(""),
+	upstreams: z.record(UpstreamNameSchema, UpstreamSchema).optional(),
+	agentId: z.union([z.literal(""), AgentIdSchema]).default(""),
+	home: z.string().trim().min(1).default("~/.acn-dsh"),
+	sessionEpoch: nonnegative().default(0),
+	connections: z.array(ConnectionSchema).max(50).default([]),
+	defaultConnection: z.string().default(""),
+	legacyEnabled: z.boolean().default(true),
+	showCompletion: z.boolean().default(true),
+	team: z.strictObject({
+		routerEndpoint: endpoint.default(""),
+		maintainerEndpoint: endpoint.default(""),
+		keyEnv: z.string().regex(/^(?:[A-Za-z_][A-Za-z0-9_]*)?$/).default(""),
+		timeoutMs: positive().default(15e3),
+		routerTimeoutMs: positive().default(5e4),
+		retryCount: nonnegative().default(3),
+		retryBaseDelayMs: positive().default(500),
+		retryMaxDelayMs: positive().default(8e3)
+	}).prefault({}),
+	llm: z.strictObject({
+		provider: z.string().default(""),
+		model: z.string().default(""),
+		maxOutputTokens: positive().default(32768),
+		timeoutMs: positive().default(6e5),
+		structuredRetries: positive().default(5)
+	}).prefault({}),
+	catalog: z.strictObject({
+		maxClaims: positive().default(20),
+		maxChars: positive().default(24e3)
+	}).prefault({}),
+	formation: z.strictObject({
+		recapOnCompaction: z.boolean().default(true),
+		idleRecap: z.boolean().default(true),
+		recapMinTurns: positive().default(10),
+		recapMinTokens: positive().default(1e5),
+		recapBatchIdleMinutes: positive().default(5),
+		recapTailIdleMinutes: positive().default(60),
+		recapScanSeconds: positive().default(30),
+		finalizeIdleMinutes: nonnegative().default(0),
+		finalizeOnDispose: z.boolean().default(false)
+	}).prefault({}),
+	inbox: z.strictObject({
+		pullOnSessionStart: z.boolean().default(true),
+		processingStaleAfterSecs: positive().default(600)
+	}).prefault({}),
+	dream: z.strictObject({
+		enabled: z.boolean().default(true),
+		minIntervalHours: positive().default(24),
+		minChangedClaims: positive().default(5),
+		checkIntervalHours: positive().default(4),
+		evidenceCalibration: z.boolean().default(false),
+		maxModelSteps: positive().max(128).default(24),
+		maxWrapUpSteps: positive().max(8).default(3),
+		evidenceMaxCalls: positive().max(256).default(32),
+		evidenceMaxSteps: positive().max(128).default(24),
+		evidenceMaxBytes: positive().max(16777216).default(1048576),
+		evidenceMaxChars: positive().max(64e3).default(16e3),
+		evidenceMaxFiles: positive().max(4096).default(256)
+	}).prefault({})
+}).superRefine((config, ctx) => {
+	if (config.upstreams !== void 0) {
+		if (config.upstream !== "" && config.upstreams[config.upstream]?.enabled !== true) ctx.addIssue({
+			code: "custom",
+			path: ["upstream"],
+			message: "Select an enabled upstream."
+		});
+	}
+	if (new Set(config.connections.map((item) => item.id)).size !== config.connections.length) ctx.addIssue({
+		code: "custom",
+		path: ["connections"],
+		message: "Connection identifiers must be unique."
+	});
+	if (config.defaultConnection !== "" && config.defaultConnection !== "legacy" && !config.connections.some((item) => item.id === config.defaultConnection && item.enabled)) ctx.addIssue({
+		code: "custom",
+		path: ["defaultConnection"],
+		message: "Default connection must be enabled."
+	});
+	if (Boolean(config.team.routerEndpoint) !== Boolean(config.team.maintainerEndpoint)) ctx.addIssue({
+		code: "custom",
+		path: ["team"],
+		message: "Configure both team endpoints or neither."
+	});
+	if (Boolean(config.llm.provider.trim()) !== Boolean(config.llm.model.trim())) ctx.addIssue({
+		code: "custom",
+		path: ["llm"],
+		message: "Configure both provider and model or neither."
+	});
+	if (config.team.retryMaxDelayMs < config.team.retryBaseDelayMs) ctx.addIssue({
+		code: "custom",
+		path: ["team", "retryMaxDelayMs"],
+		message: "Maximum retry delay must not be smaller than the base delay."
+	});
+});
+var ConfigError = class extends Error {
+	fields;
+	kind = "config";
+	constructor(fields) {
+		super(`Invalid ACN configuration: ${fields.join(", ")}`);
+		this.fields = fields;
+		this.name = "ConfigError";
+	}
+};
+function resolveConfig(input) {
+	let value = input;
+	if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+		const compatible = { ...input };
+		delete compatible["projectUpstreams"];
+		delete compatible["memory"];
+		value = compatible;
+	}
+	const parsed = ConfigSchema.safeParse(value);
+	if (!parsed.success) throw new ConfigError([...new Set(parsed.error.issues.map((issue) => issue.path.join(".") || "config"))]);
+	return parsed.data;
+}
+function upstreamsOf(config) {
+	if (config.upstreams !== void 0) return config.upstreams;
+	const items = {};
+	if (config.agentId !== "") {
+		items["personal"] = UpstreamSchema.parse({
+			name: "个人知识",
+			agentId: config.agentId,
+			legacyStorage: config.team.routerEndpoint ? "personal" : "base"
+		});
+		if (config.team.routerEndpoint) items["legacy"] = UpstreamSchema.parse({
+			name: "原有团队",
+			agentId: config.agentId,
+			enabled: config.legacyEnabled,
+			routerEndpoint: config.team.routerEndpoint,
+			maintainerEndpoint: config.team.maintainerEndpoint,
+			keyEnv: config.team.keyEnv,
+			timeoutMs: config.team.timeoutMs,
+			legacyStorage: "base"
+		});
+	}
+	for (const connection of config.connections) {
+		const { id, ...value } = connection;
+		let key = id.toLowerCase();
+		while (items[key] !== void 0 || [
+			"data",
+			"skills",
+			"logs",
+			"tmp"
+		].includes(key)) key = `${key}_copy`;
+		items[key] = UpstreamSchema.parse({
+			...value,
+			legacyStorage: "connection",
+			legacyKey: id
+		});
+	}
+	return items;
+}
+//#endregion
+//#region src/upstreams.ts
+function resolveUpstream(config, key, includeDisabled = false) {
+	const profile = upstreamsOf(config)[key];
+	if (profile === void 0 || !profile.enabled && !includeDisabled) return void 0;
+	assertStorageName(key);
+	if (profile.legacyKey !== void 0) assertStorageName(profile.legacyKey);
+	const home = profile.legacyStorage === "base" ? config.home : profile.legacyStorage === "personal" ? join(config.home, "personal") : profile.legacyStorage === "connection" ? join(config.home, "connections", profile.legacyKey ?? "") : join(config.home, key, "data");
+	return resolveConfig({
+		...config,
+		upstreams: void 0,
+		upstream: "",
+		connections: [],
+		defaultConnection: "",
+		sessionEpoch: 0,
+		home,
+		agentId: profile.agentId,
+		legacyEnabled: true,
+		team: {
+			...config.team,
+			routerEndpoint: profile.routerEndpoint,
+			maintainerEndpoint: profile.maintainerEndpoint,
+			keyEnv: profile.keyEnv,
+			timeoutMs: profile.timeoutMs
+		}
+	});
+}
+function defaultUpstream(config) {
+	return config.upstreams === void 0 ? config.agentId ? "personal" : "" : config.upstream;
+}
+async function canonicalProjectPath(cwd) {
+	const path = resolve(cwd);
+	try {
+		return await realpath(path);
+	} catch {
+		return path;
+	}
+}
+//#endregion
+//#region src/knowledge/service.ts
+function missing(error) {
+	return hasCode(error, "ENOENT") || error instanceof StoreError && error.kind === "io" && hasCode(error.cause, "ENOENT");
+}
+var AcnKnowledge = class {
+	config;
+	logger;
+	agentId;
+	mode;
+	storeContext;
+	team;
+	jobs;
+	cache;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(config, logger, credential) {
+		this.config = config;
+		this.logger = logger;
+		this.agentId = config.agentId || null;
+		this.mode = config.team.routerEndpoint ? "team" : "solo";
+		this.storeContext = this.agentId === null ? null : {
+			agentId: this.agentId,
+			paths: new AgentPaths(agentHomePath(config.home, this.agentId)),
+			mode: this.mode,
+			logger
+		};
+		this.team = this.agentId !== null && this.mode === "team" ? new TeamFacade(config.team, this.agentId, logger, credential) : null;
+		this.jobs = this.storeContext === null ? null : new DurableWorker(this.storeContext);
+	}
+	get active() {
+		return this.mode === "solo" || this.config.legacyEnabled;
+	}
+	get configured() {
+		return this.agentId !== null;
+	}
+	teamStatus() {
+		return this.team?.status() ?? {
+			mode: "solo",
+			router: { state: "unknown" },
+			maintainer: { state: "unknown" }
+		};
+	}
+	context() {
+		if (this.storeContext === null) throw new KnowledgeError("unconfigured", "Configure agentId on the acn-knowledge row first.");
+		return this.storeContext;
+	}
+	async initialize() {
+		if (!this.configured) return;
+		await new PresentationStore(this.context()).initialize();
+		await cleanupAtomicTemps(this.context().paths.root, this.logger);
+		await new DreamStore(this.context()).recover();
+		await new ClaimEditStore(this.context()).recover();
+		await new FormationStore(this.context()).recover();
+		await new InboxEffectStore(this.context()).recover();
+	}
+	async snapshot(signal, lockTimeoutMs) {
+		return this.consistentRead(async () => {
+			const context = this.context();
+			let stamp;
+			try {
+				const stat = await fs.stat(context.paths.claims, { bigint: true });
+				stamp = `${stat.mtimeNs}:${stat.ctimeNs}`;
+			} catch (error) {
+				if (!hasCode(error, "ENOENT")) throw error;
+				stamp = "missing";
+			}
+			if (this.cache !== void 0 && this.cache.stamp === stamp && performance.now() - this.cache.checked < 2e3) return structuredClone({
+				claims: this.cache.claims,
+				version: this.cache.version
+			});
+			const claims = await new ClaimStore(context).list();
+			const revisions = [...claims].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map((claim) => `${claim.id}:${claimRevision(claim)}`).join("\n");
+			const version = { claimsDigest: createHash("sha256").update(revisions).digest("hex") };
+			this.cache = {
+				stamp,
+				checked: performance.now(),
+				claims,
+				version
+			};
+			return structuredClone({
+				claims,
+				version
+			});
+		}, signal, lockTimeoutMs);
+	}
+	async knowledgeVersion(signal, lockTimeoutMs) {
+		return (await this.snapshot(signal, lockTimeoutMs)).version;
+	}
+	async listClaims(query = {}, signal) {
+		return this.consistentRead(async () => {
+			return claimListPage(await new ClaimStore(this.context()).list(), query);
+		}, signal);
+	}
+	async readClaim(id, signal) {
+		return this.consistentRead(async () => {
+			const claim = await this.readOwnedClaim(id);
+			return {
+				claim,
+				revision: claimRevision(claim)
+			};
+		}, signal);
+	}
+	async readOwnedClaim(id) {
+		let claim;
+		try {
+			claim = await new ClaimStore(this.context()).read(id);
+		} catch (error) {
+			if (missing(error)) throw new KnowledgeError("not_found", `Claim ${id} was not found.`);
+			throw error;
+		}
+		if (claim.holder !== this.agentId) throw new KnowledgeError("ownership", `Claim ${id} is not held by this agent.`);
+		return claim;
+	}
+	async updateClaim(input, signal) {
+		const parsed = ClaimUpdateSchema.safeParse(input);
+		if (!parsed.success) throw new KnowledgeError("validation", "Invalid Claim update fields.");
+		const { id, expected_revision, ...fields } = parsed.data;
+		if (!Object.values(fields).some((value) => value !== void 0)) throw new KnowledgeError("validation", "Claim update requires at least one editable field.");
+		const context = this.context();
+		const result = await withFileLock(context.paths.knowledgeLock, async () => {
+			signal?.throwIfAborted();
+			await new DreamStore(context).recoverLocked();
+			await new ClaimEditStore(context).recoverLocked();
+			await new FormationStore(context).recoverLocked();
+			await new InboxEffectStore(context).recoverLocked();
+			const current = await this.readOwnedClaim(id);
+			const revision = claimRevision(current);
+			if (expected_revision !== revision) throw new RevisionConflict(revision);
+			const next = { ...current };
+			for (const key of [
+				"name",
+				"statement",
+				"scope",
+				"evidence_summary",
+				"confidence",
+				"status"
+			]) {
+				const value = fields[key];
+				if (value !== void 0) Object.assign(next, { [key]: value });
+			}
+			validateClaimText({
+				name: next.name,
+				statement: next.statement,
+				scope: next.scope,
+				evidence_summary: next.evidence_summary
+			});
+			next.updated_at = nextClaimUpdateAt(nowSeconds(), effectiveUpdatedAt(current));
+			signal?.throwIfAborted();
+			if (context.mode === "team") await new ClaimEditStore(context).write({
+				expected_revision: revision,
+				target: next
+			});
+			await new ClaimStore(context).write(next);
+			if (context.mode === "team") {
+				await new UploadStore(context).enqueue([next], [], true);
+				await removeFile(context.paths.claimEditPending, this.logger);
+			}
+			this.cache = void 0;
+			return {
+				claim: next,
+				revision: claimRevision(next),
+				sync_pending: context.mode === "team",
+				...context.mode === "team" ? { sync_warning: "Claim 已保存到本地，等待团队同步。" } : {}
+			};
+		}, {
+			signal,
+			timeoutMs: context.lockTimeoutMs
+		});
+		await this.notifyChanged(signal);
+		return result;
+	}
+	async listTraces(query = {}, signal) {
+		return this.consistentRead(async () => {
+			const offset = query.offset ?? 0;
+			const limit = query.limit ?? 20;
+			validatePage(offset, limit);
+			const traces = (await new TraceStore(this.context()).list()).filter((trace) => trace.agent === this.agentId && (query.claimId === void 0 || trace.input_claims.includes(query.claimId) || trace.output_claims.includes(query.claimId)));
+			traces.sort((a, b) => {
+				const delta = timestampNanos(b.created_at) - timestampNanos(a.created_at);
+				return delta === 0n ? a.id < b.id ? -1 : a.id > b.id ? 1 : 0 : delta > 0n ? 1 : -1;
+			});
+			return page(traces.map(({ id, name, created_at, input_claims, output_claims }) => ({
+				id,
+				name,
+				created_at,
+				input_claims,
+				output_claims
+			})), offset, limit);
+		}, signal);
+	}
+	async readTrace(id, options = {}, signal) {
+		return this.consistentRead(async () => {
+			const offset = options.taskOffset ?? 0;
+			const limit = options.taskLimit ?? 4e3;
+			validatePage(offset, limit, MAX_TRACE_TASK_PAGE_LIMIT);
+			let trace;
+			try {
+				trace = await new TraceStore(this.context()).read(id);
+			} catch (error) {
+				if (missing(error)) throw new KnowledgeError("not_found", `Trace ${id} was not found.`);
+				throw error;
+			}
+			if (trace.agent !== this.agentId) throw new KnowledgeError("ownership", `Trace ${id} is not owned by this agent.`);
+			const chars = Array.from(trace.task);
+			const end = Math.min(offset + limit, chars.length);
+			return {
+				...trace,
+				task: chars.slice(offset, end).join(""),
+				task_offset: offset,
+				task_limit: limit,
+				task_omitted: chars.length - end,
+				next_task_offset: end < chars.length ? end : null
+			};
+		}, signal);
+	}
+	onClaimsChanged(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	async applyFormation(...args) {
+		const result = await new FormationStore(this.context()).commit(...args);
+		if (result.applied) await this.notifyChanged(args[1].signal);
+		return result;
+	}
+	async applyInboxEffect(...args) {
+		const result = await new InboxEffectStore(this.context()).commit(...args);
+		if (result.applied > 0) await this.notifyChanged(args[3].signal);
+		return result;
+	}
+	async consistentRead(action, signal, lockTimeoutMs) {
+		const context = this.context();
+		try {
+			return await withFileLock(context.paths.knowledgeLock, async () => {
+				signal?.throwIfAborted();
+				await new DreamStore(context).recoverLocked();
+				await new ClaimEditStore(context).recoverLocked();
+				await new FormationStore(context).recoverLocked();
+				await new InboxEffectStore(context).recoverLocked();
+				const boundary = await AnalysisReadBoundary.begin(context.paths.root);
+				const result = await action();
+				await boundary.finish(context.paths.root);
+				signal?.throwIfAborted();
+				return result;
+			}, {
+				signal,
+				timeoutMs: lockTimeoutMs ?? context.lockTimeoutMs
+			});
+		} catch (error) {
+			signal?.throwIfAborted();
+			if (error instanceof LockTimeoutError) throw new KnowledgeBusy();
+			throw error;
+		}
+	}
+	async notifyChanged(signal) {
+		this.cache = void 0;
+		try {
+			const version = await this.knowledgeVersion(signal);
+			for (const listener of this.listeners) try {
+				listener(version);
+			} catch {
+				this.logger.warn("Claim change observer failed.");
+			}
+		} catch {
+			this.logger.warn("Knowledge was committed; its change notice will be checked on the next foreground step.");
+		}
+	}
+	dreamStore() {
+		return new DreamStore(this.context(), async () => {
+			await new ClaimEditStore(this.context()).recoverLocked();
+			await new FormationStore(this.context()).recoverLocked();
+			await new InboxEffectStore(this.context()).recoverLocked();
+		});
+	}
+	async dreamSnapshot(signal) {
+		return withFileLock(this.context().paths.knowledgeLock, async () => {
+			await new DreamStore(this.context()).recoverLocked();
+			await new ClaimEditStore(this.context()).recoverLocked();
+			await new FormationStore(this.context()).recoverLocked();
+			await new InboxEffectStore(this.context()).recoverLocked();
+			signal.throwIfAborted();
+			return new ClaimStore(this.context()).list();
+		}, {
+			signal,
+			timeoutMs: this.context().lockTimeoutMs
+		});
+	}
+	async applyDreamGroup(...args) {
+		const result = await this.dreamStore().commitGroup(...args);
+		await this.notifyChanged(args[6].signal);
+		return result;
+	}
+};
+//#endregion
+//#region src/dsh-adapter/team-credentials.ts
+function credentialReference(reference) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(reference)) throw new ConfigError(["team.keyEnv"]);
+	return reference;
+}
+function teamCredentials(ctx) {
+	return async (reference) => {
+		const provider = ctx.get("credentials");
+		return provider === void 0 ? process.env[reference] : (await provider.resolve(credentialReference(reference)))?.value;
+	};
+}
+//#endregion
+export { defaultUpstream as a, ConnectionSchema as c, resolveConfig as d, upstreamsOf as f, canonicalProjectPath as i, UpstreamNameSchema as l, teamCredentials as n, resolveUpstream as o, AcnKnowledge as r, ConfigError as s, credentialReference as t, UpstreamSchema as u };

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-B7AI5jds.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 };