@agentconnect.md/daemon 1.0.0-rc.139 → 1.0.0-rc.140

package/dist/index.js

@@ -7383,6 +7383,8 @@ const ConfigSchema = object({
 		idleSweepMs: number().int().default(6e4),
 		shutdownDrainMs: number().int().default(25e3),
 		cancelBackstopMs: number().int().default(3e4),
+		agentStartAttempts: number().int().min(1).default(3),
+		agentStartBackoffMs: number().int().min(0).default(500),
 		maxAttachmentBytes: number().int().default(8 * 1024 * 1024)
 	}).default({
 		maxAgents: 8,
@@ -7391,6 +7393,8 @@ const ConfigSchema = object({
 		idleSweepMs: 6e4,
 		shutdownDrainMs: 25e3,
 		cancelBackstopMs: 3e4,
+		agentStartAttempts: 3,
+		agentStartBackoffMs: 500,
 		maxAttachmentBytes: 8 * 1024 * 1024
 	})
 });
@@ -13651,7 +13655,8 @@ const FRAME_SCHEMAS = {
 		usage: object({
 			used: number().int().optional(),
 			cost: number().optional()
-		}).optional()
+		}).optional(),
+		error: string().optional()
 	}),
 	"webchat/close": object({ conversationId: string().uuid() }),
 	"route/assign": RouteAssign,
@@ -85020,6 +85025,26 @@ var Daemon = class Daemon {
 		for (const cpRule of this.cpRouting?.effectiveRules() ?? []) if (!this.resolveCpAgent(cpRule.agentId)) out.add(cpRule.agentId);
 		return [...out];
 	}
+	/**
+	* Surface a turn that failed before producing a reply (agent couldn't start,
+	* ACP handshake/prompt rejected) to whichever transport owns it. Without this
+	* the failure is invisible: Slack keeps its "is thinking…" status with no
+	* message, and a webchat client never receives a terminal `webchat/done` so its
+	* UI spins forever. Best-effort — a dead Slack connection or absent CP client
+	* just means the (already logged) error goes unshown, never a second throw.
+	*/
+	surfaceTurnFailure(err, ctx) {
+		const reason = err?.message ?? String(err);
+		if (ctx.webchat) this.cpClient?.emitWebchatDone({
+			conversationId: ctx.webchat.conversationId,
+			turnId: ctx.webchat.turnId,
+			error: reason
+		});
+		else if (ctx.replyConn) {
+			if (ctx.statusThread) ctx.replyConn.setStatus(ctx.channel, ctx.statusThread, "");
+			ctx.replyConn.postMessage(ctx.channel, `⚠️ Agent failed to respond: ${reason}`, ctx.thread);
+		}
+	}
 	async dispatch(agentId, msg, integrationId, webchat) {
 		if (this.draining || this.drainingAgents.has(agentId)) {
 			this.log.debug(`dispatch: skipped for agent "${agentId}" (draining)`);
@@ -85037,6 +85062,13 @@ var Daemon = class Daemon {
 			handled = await this.sessions.handle(agentId, msg);
 		} catch (err) {
 			this.store.setSessionState(key, "idle", this.clock.now());
+			this.surfaceTurnFailure(err, {
+				webchat,
+				replyConn,
+				channel: msg.channel,
+				thread: msg.thread,
+				statusThread
+			});
 			throw err;
 		}
 		const { sessionId, blocks } = handled;
@@ -85109,6 +85141,16 @@ var Daemon = class Daemon {
 			}
 			for (const ev of rec.onFinal()) this.recordEvent(agentId, msg.channel, statusThread, ev);
 			await p.applyChain;
+		} catch (err) {
+			this.clearIdle(p);
+			this.surfaceTurnFailure(err, {
+				webchat,
+				replyConn,
+				channel: msg.channel,
+				thread: msg.thread,
+				statusThread
+			});
+			throw err;
 		} finally {
 			this.clearIdle(p);
 			this.pending.delete(sessionId);
@@ -85321,14 +85363,48 @@ var Daemon = class Daemon {
 	async ensureHostAsync(agentId) {
 		const stopping = this.hostStopping.get(agentId);
 		if (stopping) await stopping;
-		const host = this.ensureHost(agentId, this.cfg);
 		let p = this.hostStarts.get(agentId);
 		if (!p) {
-			p = host.start();
+			p = this.startHostWithRetry(agentId);
 			this.hostStarts.set(agentId, p);
+			p.catch(() => {
+				if (this.hostStarts.get(agentId) === p) this.hostStarts.delete(agentId);
+			});
 		}
-		await p;
-		return host;
+		return await p;
+	}
+	/** Launch an agent's ACP host — spawn + the `initialize` handshake — retrying a
+	*  failed start up to `agentStartAttempts` times with a fixed backoff. Each attempt
+	*  builds a FRESH host; a failed start()'s half-spawned child is reaped before the
+	*  next try. On success the started host is left memoized in `this.hosts`; when every
+	*  attempt fails the last error is thrown (dispatch surfaces it to the session). */
+	async startHostWithRetry(agentId) {
+		const attempts = Math.max(1, this.cfg.limits.agentStartAttempts);
+		let lastErr;
+		for (let i = 1; i <= attempts; i++) {
+			const host = this.ensureHost(agentId, this.cfg);
+			try {
+				await host.start();
+				return host;
+			} catch (err) {
+				lastErr = err;
+				this.hosts.delete(agentId);
+				await host.stop().catch(() => {});
+				if (i < attempts) {
+					const backoff = this.cfg.limits.agentStartBackoffMs;
+					this.log.warn(`acp: agent "${agentId}" start attempt ${i}/${attempts} failed (${err.message}) — retrying in ${backoff}ms`);
+					await this.sleep(backoff);
+				} else this.log.error(`acp: agent "${agentId}" failed to start after ${attempts} attempt(s): ${formatErr(err)}`);
+			}
+		}
+		throw lastErr;
+	}
+	/** Clock-driven delay (so a FakeClock stays deterministic in tests). */
+	sleep(ms) {
+		const delay = Math.min(Math.max(0, ms), 2147483647);
+		return new Promise((resolve) => {
+			this.clock.setTimeout(() => resolve(), delay);
+		});
 	}
 	replyConnFor(agentId, integrationId) {
 		const intId = integrationId ?? this.agents.get(agentId)?.integrations[0]?.id;