@agentconnect.md/daemon 1.0.0-rc.15 → 1.0.0-rc.17

package/dist/index.js

@@ -23126,6 +23126,34 @@ function routeRules(msg, rules, threadOwner) {
 	return null;
 }
 //#endregion
+//#region src/commands/commands.ts
+/** Accepted command prefixes (Slack uses `!`; `/` is for future platforms). */
+const COMMAND_PREFIXES = ["!", "/"];
+const STOP_WORDS = /* @__PURE__ */ new Set(["stop", "cancel"]);
+const QUEUE_WORDS = /* @__PURE__ */ new Set(["queue"]);
+/**
+* Parse a leading control command from a message's text. Returns `null` when the
+* text is not a recognized command (so it flows to the agent unchanged). The
+* prefix must be the first non-whitespace character and be followed immediately by
+* a known command word, so ordinary text like `hello!` or `! note` is never a
+* command.
+*/
+function parseCommand(raw) {
+	const text = raw.trimStart();
+	const prefix = COMMAND_PREFIXES.find((p) => text.startsWith(p));
+	if (!prefix) return null;
+	const m = /^([a-zA-Z]+)([\s\S]*)$/.exec(text.slice(prefix.length));
+	if (!m) return null;
+	const word = m[1].toLowerCase();
+	const arg = (m[2] ?? "").trim();
+	if (STOP_WORDS.has(word)) return { kind: "stop" };
+	if (QUEUE_WORDS.has(word)) return {
+		kind: "queue",
+		text: arg
+	};
+	return null;
+}
+//#endregion
 //#region src/router/routing-rule.ts
 /**
 * Resolve an agent to its first Slack integration's `{ integrationId, botUserId }`.
@@ -80536,6 +80564,7 @@ const LOADING_MSGS = [
 	"Crunching through it…",
 	"Hang tight…"
 ];
+const MAX_QUEUED_PER_SESSION = 10;
 var Daemon = class {
 	opts;
 	store;
@@ -80697,6 +80726,11 @@ var Daemon = class {
 		}
 		this.seenMsgIds.add(msg.msgId);
 		if (this.seenMsgIds.size > 2e3) this.seenMsgIds.clear();
+		const command = parseCommand(msg.text);
+		if (command) {
+			this.handleCommand(command, msg);
+			return;
+		}
 		const result = routeRules(msg, this.mergedRules(), (c, t) => this.sessions.threadOwner(c, t));
 		if (!result) {
 			this.log.debug(`routing: dropped message in ch=${msg.channel} (no agent matched — not a mention of a known bot, not a subscribed 'all' channel, not a thread/DM hit)`);
@@ -80705,6 +80739,67 @@ var Daemon = class {
 		this.log.info(`routing: ch=${msg.channel} → agent "${result.agentId}" (integration ${result.integrationId})`);
 		this.dispatch(result.agentId, msg, result.integrationId).catch((err) => this.log.error(`dispatch failed for agent "${result.agentId}": ${err.stack ?? err}`));
 	}
+	queued = /* @__PURE__ */ new Map();
+	/**
+	* Handle an in-conversation control command. Resolves the target agent via the
+	* same routing ladder as a normal message (so thread-affinity + per-integration
+	* `allowedUserIds` authz apply), then acts on that agent's session in this
+	* (channel, thread).
+	*/
+	handleCommand(command, msg) {
+		const target = routeRules(msg, this.mergedRules(), (c, t) => this.sessions.threadOwner(c, t));
+		if (!target) {
+			this.log.debug(`command: '${command.kind}' in ch=${msg.channel} — no agent resolved, ignoring`);
+			return;
+		}
+		const conn = this.replyConnFor(target.agentId, target.integrationId);
+		const thread = msg.thread ?? msg.msgId;
+		const acpSessionId = this.store.getSession(sessionKey(msg.platform, msg.channel, thread, target.agentId))?.acpSessionId;
+		const inflight = !!(acpSessionId && this.pending.has(acpSessionId));
+		if (command.kind === "stop") {
+			if (!inflight) {
+				conn?.postMessage(msg.channel, "Nothing is running to stop.", thread);
+				return;
+			}
+			this.queued.delete(acpSessionId);
+			this.log.info(`command: stop → agent "${target.agentId}" session ${acpSessionId}`);
+			this.hosts.get(target.agentId)?.cancel(acpSessionId).catch((err) => this.log.error(`command stop: cancel failed: ${err.message}`));
+			conn?.postMessage(msg.channel, "🛑 Stopped.", thread);
+			return;
+		}
+		if (!command.text) {
+			conn?.postMessage(msg.channel, "Usage: `!queue <message>` — runs when the current turn finishes.", thread);
+			return;
+		}
+		const payload = {
+			...msg,
+			text: command.text
+		};
+		if (!inflight) {
+			this.log.info(`command: queue → agent "${target.agentId}" idle, dispatching now`);
+			this.dispatch(target.agentId, payload, target.integrationId).catch((err) => this.log.error(`queued dispatch failed for agent "${target.agentId}": ${err.stack ?? err}`));
+			return;
+		}
+		const q = this.queued.get(acpSessionId) ?? [];
+		if (q.length >= MAX_QUEUED_PER_SESSION) {
+			this.log.warn(`command: queue → agent "${target.agentId}" session ${acpSessionId} full (${q.length}), rejected`);
+			conn?.postMessage(msg.channel, `Queue is full (${MAX_QUEUED_PER_SESSION} pending) — wait for the current turn to finish.`, thread);
+			return;
+		}
+		q.push(payload);
+		this.queued.set(acpSessionId, q);
+		this.log.info(`command: queue → agent "${target.agentId}" session ${acpSessionId} (depth ${q.length})`);
+		conn?.postMessage(msg.channel, `📥 Queued (#${q.length}) — will run when the current turn finishes.`, thread);
+	}
+	/** Drain one buffered message for a session whose turn just finished (FIFO). */
+	flushQueued(agentId, sessionId, integrationId) {
+		const q = this.queued.get(sessionId);
+		if (!q || q.length === 0) return;
+		const next = q.shift();
+		if (q.length === 0) this.queued.delete(sessionId);
+		this.log.info(`queue: dispatching buffered message to agent "${agentId}" session ${sessionId} (${q.length} left)`);
+		this.dispatch(agentId, next, integrationId).catch((err) => this.log.error(`queued dispatch failed for agent "${agentId}": ${err.stack ?? err}`));
+	}
 	/** Local layer (agent.json) ∪ resolved CP layer; unservable CP rules are dropped + warn-logged. */
 	mergedRules() {
 		const local = [...this.agents.values()].flatMap((a) => rulesFromAgent(a, this.botUserIds));
@@ -80747,6 +80842,7 @@ var Daemon = class {
 		} finally {
 			this.pending.delete(sessionId);
 		}
+		this.flushQueued(agentId, sessionId, integrationId);
 	}
 	/** Route a converger action: set-status → setStatus (loading_messages only when not clearing); else postMessage. */
 	async applyAction(action, conn, channel, thread) {