@agentconnect.md/daemon 1.0.0-rc.24 → 1.0.0-rc.25

package/dist/index.js

@@ -7567,6 +7567,9 @@ const AgentSchema = object({
 		"paused"
 	]).default("active"),
 	runtime: string(),
+	description: string().optional(),
+	reasoningEffort: string().optional(),
+	executionMode: string().optional(),
 	runtimeOverrides: object({
 		model: string().optional(),
 		env: array(object({
@@ -22985,6 +22988,44 @@ function watch$1(paths, options = {}) {
 	return watcher;
 }
 //#endregion
+//#region src/agents/cp-overlay.ts
+/** Apply a CP `AgentSpec` onto a local agent, returning a new overlaid agent. */
+function overlayCpSpec(base, spec) {
+	const envMap = new Map((base.runtimeOverrides?.env ?? []).map((e) => [e.name, e.value]));
+	for (const [name, value] of Object.entries(spec.env ?? {})) envMap.set(name, value);
+	const env = [...envMap].map(([name, value]) => ({
+		name,
+		value
+	}));
+	return {
+		...base,
+		name: spec.name,
+		...spec.description !== void 0 ? { description: spec.description } : {},
+		...spec.reasoningEffort !== void 0 ? { reasoningEffort: spec.reasoningEffort } : {},
+		...spec.executionMode !== void 0 ? { executionMode: spec.executionMode } : {},
+		runtimeOverrides: {
+			...base.runtimeOverrides,
+			...spec.model !== void 0 ? { model: spec.model } : {},
+			env
+		}
+	};
+}
+/**
+* Runtime config the daemon can only surface to an ACP child as environment
+* variables: ACP `session/new`/`initialize` carry no model or system-prompt
+* field (SDK v1), so model / reasoning / prompt are exposed under `AGENTCONNECT_*`
+* for runtimes that read them. (`runtimeOverrides.env` is applied separately by
+* `agentChildEnv`.) Only emits a key when the value is set.
+*/
+function cpRuntimeEnv(agent) {
+	const out = {};
+	if (agent.runtimeOverrides?.model) out.AGENTCONNECT_MODEL = agent.runtimeOverrides.model;
+	if (agent.reasoningEffort) out.AGENTCONNECT_REASONING_EFFORT = agent.reasoningEffort;
+	if (agent.executionMode) out.AGENTCONNECT_EXECUTION_MODE = agent.executionMode;
+	if (agent.description) out.AGENTCONNECT_SYSTEM_PROMPT = agent.description;
+	return out;
+}
+//#endregion
 //#region src/reconciler/reconciler.ts
 /** Stable identity-free signature of an agent's effective config. Excludes the
 *  loader-only `dir`/`env` fields (present on `LoadedAgent`) so the comparison is
@@ -23042,6 +23083,10 @@ var LocalStore = class {
         id INTEGER PRIMARY KEY CHECK (id = 1),
         routingEpoch INTEGER, assignments TEXT, globalRules TEXT
       );
+      CREATE TABLE IF NOT EXISTS cp_agents (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        specs TEXT
+      );
     `);
 	}
 	getSession(key) {
@@ -23075,6 +23120,13 @@ var LocalStore = class {
 			globalRules
 		});
 	}
+	getCpAgents() {
+		return this.db.prepare("SELECT specs FROM cp_agents WHERE id = 1").get();
+	}
+	setCpAgents(specs) {
+		this.db.prepare(`INSERT INTO cp_agents (id, specs) VALUES (1, @specs)
+         ON CONFLICT(id) DO UPDATE SET specs=excluded.specs`).run({ specs });
+	}
 	close() {
 		this.db.close();
 	}
@@ -80533,6 +80585,14 @@ var CpClient = class {
 			case "route/update":
 				this.deps.configApply.applyRouteUpdate(frame.payload);
 				return;
+			case "agent/upsert": {
+				const u = frame.payload;
+				this.deps.configApply.applyAgentUpsert(u.agentId, u.spec);
+				return;
+			}
+			case "agent/remove":
+				this.deps.configApply.applyAgentRemove(frame.payload.agentId);
+				return;
 			case "agent/launch":
 			case "agent/stop":
 			case "agent/prompt":
@@ -80586,6 +80646,46 @@ var CpCronRegistry = class {
 	}
 };
 //#endregion
+//#region src/cp/cp-agent-registry.ts
+var CpAgentRegistry = class {
+	io;
+	onChange;
+	specs = /* @__PURE__ */ new Map();
+	constructor(io, onChange) {
+		this.io = io;
+		this.onChange = onChange;
+		const s = io.load();
+		if (s) this.specs = new Map(Object.entries(s));
+	}
+	/** Add or replace one agent's spec (agent/upsert EVT). */
+	upsert(agentId, spec) {
+		this.specs.set(agentId, spec);
+		this.changed();
+	}
+	/** Drop one agent's spec (agent/remove EVT). No-op if absent. */
+	remove(agentId) {
+		if (this.specs.delete(agentId)) this.changed();
+	}
+	/** Make the live set exactly `roster` (register/ok reconcile snapshot). */
+	converge(roster) {
+		const next = /* @__PURE__ */ new Map();
+		for (const { agentId, ...spec } of roster) next.set(agentId, spec);
+		this.specs = next;
+		this.changed();
+	}
+	get(agentId) {
+		return this.specs.get(agentId);
+	}
+	/** agentIds the CP currently wants present. */
+	ids() {
+		return [...this.specs.keys()];
+	}
+	changed() {
+		this.io.save(Object.fromEntries(this.specs));
+		this.onChange();
+	}
+};
+//#endregion
 //#region src/cp/config-apply.ts
 const LOG_LEVELS = /* @__PURE__ */ new Set([
 	"trace",
@@ -80670,6 +80770,7 @@ var Daemon = class {
 	opts;
 	store;
 	agents = /* @__PURE__ */ new Map();
+	fileAgents = /* @__PURE__ */ new Map();
 	hosts = /* @__PURE__ */ new Map();
 	connections = [];
 	scheduler;
@@ -80686,6 +80787,7 @@ var Daemon = class {
 	runtimeNames = {};
 	cpClient;
 	cpCrons;
+	cpAgents;
 	botUserIds = {};
 	cpRouting;
 	constructor(opts = {}) {
@@ -80710,7 +80812,7 @@ var Daemon = class {
 		this.log.info(`control plane: ${cfg.controlPlane?.enabled ? `enabled (${cfg.controlPlane.url ?? "no url"})` : "disabled — running local"}`);
 		this.agentsDir = cfg.agentsDir;
 		const agents = this.loadAgentList();
-		for (const a of agents) this.agents.set(a.id, a);
+		this.fileAgents = new Map(agents.map((a) => [a.id, a]));
 		this.log.info(`loaded ${agents.length} agent(s) from ${this.agentsDir}${agents.length ? `: ${agents.map((a) => a.id).join(", ")}` : ""}`);
 		this.root = root;
 		const resolvedRuntimes = await resolveRuntimes(cfg, root, {
@@ -80734,6 +80836,14 @@ var Daemon = class {
 			},
 			save: (s) => this.store.setCpRouting(s.routingEpoch, JSON.stringify(s.assignments), JSON.stringify(s.globalRules))
 		});
+		this.cpAgents = new CpAgentRegistry({
+			load: () => {
+				const row = this.store.getCpAgents();
+				return row ? JSON.parse(row.specs) : void 0;
+			},
+			save: (s) => this.store.setCpAgents(JSON.stringify(s))
+		}, () => void this.reconcile().catch((err) => this.log.error(`cp: agent reconcile failed: ${err.stack ?? err}`)));
+		for (const a of this.effectiveAgents()) this.agents.set(a.id, a);
 		this.sessions = new SessionManager({
 			store: this.store,
 			hostFor: (agentId) => this.ensureHostAsync(agentId),
@@ -80789,8 +80899,51 @@ var Daemon = class {
 	loadAgentList() {
 		return this.opts.agentName ? [selectAgent(this.agentsDir, this.opts.agentName)] : loadAgents(this.agentsDir);
 	}
+	/**
+	* Effective agent set = on-disk `agent.json` base with the CP spec overlaid
+	* (joined by id; CP owns name/description/model/reasoning/execution/env, the
+	* file owns runtime/workspace). CP-only ids with no local base are skipped —
+	* not runnable — and surfaced via cpDegradedScopes().
+	*/
+	effectiveAgents() {
+		return [...this.fileAgents.values()].map((base) => {
+			const spec = this.cpAgents?.get(base.id);
+			return spec ? overlayCpSpec(base, spec) : base;
+		});
+	}
+	/**
+	* Converge the running set to the desired effective agents. Driven by both the
+	* `agents/**` file-watch AND CP convergence (agent/upsert, agent/remove, the
+	* register/ok roster, via the registry's onChange). `diffAgents` detects a
+	* changed effective config (runtime/workspace/model/prompt/env/…) and restarts
+	* the host lazily so the next session picks up fresh config.
+	*
+	* Single-flight: overlapping triggers (e.g. a burst of CP frames, or a file
+	* event landing mid-reconcile) coalesce into one trailing re-run so we never
+	* run two passes concurrently and double-evict a host.
+	*/
+	reconcileRun;
+	reconcilePending = false;
 	async reconcile() {
-		const desired = this.loadAgentList();
+		if (this.reconcileRun) {
+			this.reconcilePending = true;
+			return this.reconcileRun;
+		}
+		this.reconcileRun = this.runReconcile();
+		try {
+			await this.reconcileRun;
+		} finally {
+			this.reconcileRun = void 0;
+		}
+		if (this.reconcilePending) {
+			this.reconcilePending = false;
+			await this.reconcile();
+		}
+	}
+	async runReconcile() {
+		const files = this.loadAgentList();
+		this.fileAgents = new Map(files.map((a) => [a.id, a]));
+		const desired = this.effectiveAgents();
 		const { toStart, toStop, toRestart } = diffAgents(desired, this.agents);
 		if (toStart.length || toStop.length || toRestart.length) this.log.info(`reconcile: ${desired.length} desired agent(s) from ${this.agentsDir}; start=[${toStart.map((a) => a.id).join(", ")}] stop=[${toStop.join(", ")}] restart=[${toRestart.map((a) => a.id).join(", ")}]`);
 		else this.log.debug(`reconcile: no changes (${desired.length} desired agent(s))`);
@@ -80825,7 +80978,10 @@ var Daemon = class {
 			if (!runtime) throw new Error(`runtime "${agent.runtime}" not available: not installed on this host, or absent from config.runtimes / the ACP registry`);
 			host = new AcpHost(runtime, {
 				onUpdate,
-				env: agentChildEnv(agent),
+				env: {
+					...agentChildEnv(agent),
+					...cpRuntimeEnv(agent)
+				},
 				log: this.log
 			});
 		}
@@ -80929,10 +81085,15 @@ var Daemon = class {
 	resolveCpAgent(agentId) {
 		return resolveAgentIntegration(this.agents.get(agentId), this.botUserIds);
 	}
-	/** agentIds of CP rules that currently resolve to null (no servable Slack integration). */
+	/**
+	* agentIds the daemon can't fully serve: CP routing rules with no servable
+	* Slack integration, plus CP agent specs with no on-disk base (no runtime /
+	* workspace to materialize — the spec alone can't be run).
+	*/
 	cpDegradedScopes() {
 		const out = /* @__PURE__ */ new Set();
 		for (const cpRule of this.cpRouting?.effectiveRules() ?? []) if (!this.resolveCpAgent(cpRule.agentId)) out.add(cpRule.agentId);
+		for (const id of this.cpAgents?.ids() ?? []) if (!this.fileAgents.has(id)) out.add(id);
 		return [...out];
 	}
 	async dispatch(agentId, msg, integrationId) {
@@ -80996,6 +81157,7 @@ var Daemon = class {
 			},
 			applyReconcileSnapshot: (snap) => {
 				this.cpCrons?.converge(snap.crons);
+				this.cpAgents?.converge(snap.agents);
 				this.cpRouting?.converge({
 					routingEpoch: snap.routingEpoch,
 					assignments: snap.assignments,
@@ -81003,7 +81165,10 @@ var Daemon = class {
 				});
 				if (snap.leases.length) this.log.debug(`cp: ${snap.leases.length} lease(s) noted (secrets handled later)`);
 				if (snap.assignments.length) this.log.debug(`cp: converged ${snap.assignments.length} assignment(s)`);
+				if (snap.agents.length) this.log.debug(`cp: converged ${snap.agents.length} agent spec(s)`);
 			},
+			applyAgentUpsert: (agentId, spec) => this.cpAgents?.upsert(agentId, spec),
+			applyAgentRemove: (agentId) => this.cpAgents?.remove(agentId),
 			upsertCron: (cron) => this.cpCrons.upsert(cron),
 			removeCron: (cronId) => this.cpCrons.remove(cronId),
 			applyRouteAssign: (a) => this.cpRouting?.upsertAssign(a),