@agentconnect.md/daemon 1.0.0-rc.122 → 1.0.0-rc.124

package/dist/index.js

@@ -7651,7 +7651,6 @@ const SlackConfigSchema = object({
 	signingSecret: string().optional(),
 	botUserId: string().optional(),
 	allowedUserIds: array(string()).default([]),
-	notificationChannelId: string().optional(),
 	bindRules: array(BindRuleConfigSchema).default([])
 });
 const IntegrationSchema = object({
@@ -12856,7 +12855,11 @@ const AuthOk = object({
 * agent/*, and event/session. Its canonical string form is
 * `${platform}:${channel}:${thread ?? "-"}`.
 */
-const Platform = _enum(["slack", "telegram"]);
+const Platform = _enum([
+	"slack",
+	"telegram",
+	"webchat"
+]);
 const SessionKey = object({
 	platform: Platform,
 	channel: string(),
@@ -13144,7 +13147,6 @@ const IntegrationSlackConfig = object({
 	botToken: string(),
 	appToken: string(),
 	allowedUserIds: array(string()).default([]),
-	notificationChannelId: string().optional(),
 	bindRules: array(IntegrationBindRule).default([])
 });
 /**
@@ -13511,6 +13513,99 @@ const FactsRuntimeProfile = object({
 	acpProtocolVersion: number().int().optional(),
 	toolCalling: boolean()
 });
+/**
+* Full snapshot of the daemon's installed runtimes — D→C EVT (protocol §7.3a),
+* emitted on each register and again once the background probe sweep completes
+* (with the learned `models[]`). REPLACE semantics: the CP reconciles its
+* stored runtime list for the daemon to exactly `runtimes[]`, pruning runtimes
+* that are no longer installed. Idempotent (latest-wins). Supersedes the
+* per-runtime `facts/runtime-profile` upsert.
+*/
+const DaemonRuntimes = object({ runtimes: array(FactsRuntimeProfile) });
+/** Non-secret config update — C→D EVT, protocol §8.3 / frame #26. */
+const ConfigPush = object({ keys: record(string(), unknown()) });
+/** Fleet: drain+exit, supervisor restarts — C→D REQ, protocol §8.3 / frame #27. */
+const DaemonRestart = object({
+	reason: string(),
+	drainFirst: boolean().default(true)
+});
+/** Fleet: drain+exit for version bump — C→D REQ, protocol §8.3 / frame #28. */
+const DaemonUpgrade = object({
+	targetVersion: string(),
+	drainFirst: boolean().default(true)
+});
+/** Reply to a fleet restart/upgrade REQ (protocol §8.3). */
+const DaemonControlAck = object({
+	accepted: boolean(),
+	willDrainUntil: string().datetime().optional()
+});
+/**
+* Generic acknowledgement for REQs whose reply is just `ack` in the frame index
+* (cron/upsert, cron/remove, agent/stop). Kept permissive but typed.
+*/
+const Ack = object({
+	ok: boolean(),
+	reason: string().optional()
+});
+const ErrorFrame = object({
+	code: _enum([
+		"UNKNOWN_FRAME",
+		"FRAME_TOO_LARGE",
+		"PROTOCOL_STATE",
+		"BAD_PAYLOAD",
+		"AUTH_FAILED",
+		"ATTESTATION_INVALID",
+		"STALE_EPOCH",
+		"STALE_LAUNCH",
+		"NO_SESSION",
+		"SCOPE_DENIED",
+		"LEASE_EXPIRED",
+		"LEASE_DENIED",
+		"RATE_LIMITED",
+		"INTERNAL"
+	]),
+	message: string(),
+	retryable: boolean(),
+	details: record(string(), unknown()).optional()
+});
+//#endregion
+//#region ../protocol/dist/frames/webchat.js
+const WebchatMessage = object({
+	conversationId: string().uuid(),
+	agentId: string().uuid(),
+	text: string(),
+	user: string().optional()
+});
+const WebchatAck = object({
+	accepted: boolean(),
+	turnId: string().uuid(),
+	reason: _enum([
+		"queued",
+		"no_agent",
+		"busy"
+	]).optional()
+});
+const WebchatEvent = discriminatedUnion("kind", [
+	object({
+		kind: literal("message"),
+		text: string()
+	}),
+	object({
+		kind: literal("thinking"),
+		text: string()
+	}),
+	object({
+		kind: literal("tool_call"),
+		toolCallId: string(),
+		title: string(),
+		status: string()
+	}),
+	object({
+		kind: literal("tool_update"),
+		toolCallId: string(),
+		status: string()
+	})
+]);
 //#endregion
 //#region ../protocol/dist/frame.js
 /**
@@ -13537,6 +13632,24 @@ const FRAME_SCHEMAS = {
 	"agent/remove": AgentRemove,
 	"agent/activity": AgentActivity,
 	"agent/scope-denied": AgentScopeDenied,
+	"webchat/message": WebchatMessage,
+	"webchat/ack": WebchatAck,
+	"webchat/output": object({
+		conversationId: string().uuid(),
+		turnId: string().uuid(),
+		index: number().int(),
+		event: WebchatEvent
+	}),
+	"webchat/done": object({
+		conversationId: string().uuid(),
+		turnId: string().uuid(),
+		stopReason: string().optional(),
+		usage: object({
+			used: number().int().optional(),
+			cost: number().optional()
+		}).optional()
+	}),
+	"webchat/close": object({ conversationId: string().uuid() }),
 	"route/assign": RouteAssign,
 	"route/assign/ack": RouteAssignAck,
 	"route/update": RouteUpdate,
@@ -13558,7 +13671,7 @@ const FRAME_SCHEMAS = {
 	"event/session": EventSession,
 	"usage/report": UsageReport,
 	"facts/runtime-profile": FactsRuntimeProfile,
-	"facts/daemon-runtimes": object({ runtimes: array(FactsRuntimeProfile) }),
+	"facts/daemon-runtimes": DaemonRuntimes,
 	"session/list": SessionListReq,
 	"session/list/page": SessionListPage,
 	"session/history": SessionHistoryReq,
@@ -13573,44 +13686,12 @@ const FRAME_SCHEMAS = {
 	"workspace/gitstatus/result": WorkspaceGitStatus,
 	"workspace/gitpull": WorkspaceGitPullReq,
 	"workspace/gitpull/result": WorkspaceGitPullResult,
-	"config/push": object({ keys: record(string(), unknown()) }),
-	"daemon/restart": object({
-		reason: string(),
-		drainFirst: boolean().default(true)
-	}),
-	"daemon/upgrade": object({
-		targetVersion: string(),
-		drainFirst: boolean().default(true)
-	}),
-	"daemon/control/ack": object({
-		accepted: boolean(),
-		willDrainUntil: string().datetime().optional()
-	}),
-	ack: object({
-		ok: boolean(),
-		reason: string().optional()
-	}),
-	error: object({
-		code: _enum([
-			"UNKNOWN_FRAME",
-			"FRAME_TOO_LARGE",
-			"PROTOCOL_STATE",
-			"BAD_PAYLOAD",
-			"AUTH_FAILED",
-			"ATTESTATION_INVALID",
-			"STALE_EPOCH",
-			"STALE_LAUNCH",
-			"NO_SESSION",
-			"SCOPE_DENIED",
-			"LEASE_EXPIRED",
-			"LEASE_DENIED",
-			"RATE_LIMITED",
-			"INTERNAL"
-		]),
-		message: string(),
-		retryable: boolean(),
-		details: record(string(), unknown()).optional()
-	})
+	"config/push": ConfigPush,
+	"daemon/restart": DaemonRestart,
+	"daemon/upgrade": DaemonUpgrade,
+	"daemon/control/ack": DaemonControlAck,
+	ack: Ack,
+	error: ErrorFrame
 };
 Object.keys(FRAME_SCHEMAS);
 /**
@@ -13640,6 +13721,11 @@ discriminatedUnion("type", [
 	frame("agent/remove", FRAME_SCHEMAS["agent/remove"]),
 	frame("agent/activity", FRAME_SCHEMAS["agent/activity"]),
 	frame("agent/scope-denied", FRAME_SCHEMAS["agent/scope-denied"]),
+	frame("webchat/message", FRAME_SCHEMAS["webchat/message"]),
+	frame("webchat/ack", FRAME_SCHEMAS["webchat/ack"]),
+	frame("webchat/output", FRAME_SCHEMAS["webchat/output"]),
+	frame("webchat/done", FRAME_SCHEMAS["webchat/done"]),
+	frame("webchat/close", FRAME_SCHEMAS["webchat/close"]),
 	frame("route/assign", FRAME_SCHEMAS["route/assign"]),
 	frame("route/assign/ack", FRAME_SCHEMAS["route/assign/ack"]),
 	frame("route/update", FRAME_SCHEMAS["route/update"]),
@@ -24999,8 +25085,18 @@ const pickRule = (r, via) => ({
 * (2) thread affinity (highest after explicit @; bypasses the kind filter, gated on
 * reachable-bot count) → (3) CP per-sessionKey override → (4/5) kind precedence
 * mention > dm > keyword > auto within the chosen layer.
+*
+* `explicitAgentId` short-circuits the whole ladder: a webchat turn names its target
+* agent (`webchat/message.agentId`), so there is nothing to arbitrate — it routes
+* directly to that agent (integrationId '' — webchat's data plane is the control WS,
+* not a platform integration). Null if that agentId isn't a servable rule here.
 */
-function routeRules(msg, rules, threadOwner) {
+function routeRules(msg, rules, threadOwner, explicitAgentId) {
+	if (explicitAgentId !== void 0) return {
+		agentId: explicitAgentId,
+		integrationId: "",
+		via: "mention"
+	};
 	if (msg.sender.isBot) return null;
 	const authz = (r) => !r.allowedUserIds || r.allowedUserIds.length === 0 || r.allowedUserIds.includes(msg.sender.id);
 	const scopeCandidates = rules.filter((r) => scopeMatches(r, msg) && authz(r));
@@ -83055,6 +83151,22 @@ var CpClient = class {
 		if (this.state !== "READY" && this.state !== "DRAINING") return;
 		this.transport?.send(encode(buildEnvelope("cron/report", report)));
 	}
+	/**
+	* Emit one chunk of a webchat turn's reply stream (D→C `webchat/output` EVT).
+	* Ordered per-connection (TCP); `output.index` is the per-turn assembly counter.
+	* No-op unless READY/DRAINING — a dropped chunk is lost (unlike latest-wins
+	* telemetry), so the daemon only emits while connected. Content is inline, bounded
+	* by the 256 KiB frame cap; the caller chunks any oversize single event.
+	*/
+	emitWebchatOutput(output) {
+		if (this.state !== "READY" && this.state !== "DRAINING") return;
+		this.transport?.send(encode(buildEnvelope("webchat/output", output)));
+	}
+	/** Emit a webchat turn's completion (D→C `webchat/done` EVT). No-op unless READY/DRAINING. */
+	emitWebchatDone(done) {
+		if (this.state !== "READY" && this.state !== "DRAINING") return;
+		this.transport?.send(encode(buildEnvelope("webchat/done", done)));
+	}
 	request(type, payload) {
 		const frame = buildEnvelope(type, payload);
 		return this.correlator.request(frame, (e) => this.transport.send(e));
@@ -83231,6 +83343,20 @@ var CpClient = class {
 			case "workspace/gitpull":
 				this.deps.workspaceGit.pull(frame.payload.agentId).then((result) => this.reply(frame, "workspace/gitpull/result", result)).catch((err) => this.workspaceError(frame.id, "workspace/gitpull", err));
 				return;
+			case "webchat/message":
+				if (!this.deps.onWebchatMessage) {
+					this.sendError(frame.id, "INTERNAL", "webchat not supported", false);
+					return;
+				}
+				try {
+					this.reply(frame, "webchat/ack", this.deps.onWebchatMessage(frame.payload));
+				} catch (err) {
+					this.sendError(frame.id, "INTERNAL", `webchat/message failed: ${err.message}`, false);
+				}
+				return;
+			case "webchat/close":
+				this.deps.onWebchatClose?.(frame.payload);
+				return;
 			default:
 				this.deps.log.debug(`cp: ignoring ${frame.type}`);
 				return;
@@ -83951,7 +84077,6 @@ function toIntegration(spec) {
 			botToken: spec.slack.botToken,
 			appToken: spec.slack.appToken,
 			allowedUserIds: spec.slack.allowedUserIds,
-			...spec.slack.notificationChannelId ? { notificationChannelId: spec.slack.notificationChannelId } : {},
 			bindRules: spec.slack.bindRules
 		}
 	};
@@ -84114,6 +84239,28 @@ function formatErr(err) {
 	return e?.stack ?? String(err);
 }
 const MAX_QUEUED_PER_SESSION = 10;
+const WEBCHAT_CHUNK_BYTES = 32 * 1024;
+/** Split `text` into pieces whose UTF-8 byte length each stays under WEBCHAT_CHUNK_BYTES
+*  so no single webchat/output frame exceeds the 256 KiB cap. Splits on byte budget by
+*  character (never mid-code-point); short text returns a single piece. */
+function chunkText(text) {
+	if (Buffer.byteLength(text) <= WEBCHAT_CHUNK_BYTES) return [text];
+	const out = [];
+	let buf = "";
+	let bytes = 0;
+	for (const ch of text) {
+		const w = Buffer.byteLength(ch);
+		if (bytes + w > WEBCHAT_CHUNK_BYTES && buf) {
+			out.push(buf);
+			buf = "";
+			bytes = 0;
+		}
+		buf += ch;
+		bytes += w;
+	}
+	if (buf) out.push(buf);
+	return out;
+}
 const IDLE_FLUSH_MS = 2e3;
 /** Build the wire SessionKey (protocol §5) for a pending turn — what `drain/done`
 *  reports as released so the CP may reassign it. Uses the real `thread` (absent for
@@ -84593,6 +84740,61 @@ var Daemon = class Daemon {
 		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}": ${formatErr(err)}`));
 	}
+	/**
+	* Handle an inbound webchat turn (C→D `webchat/message`). webchat is the one
+	* integration whose data plane is the daemon↔CP control WS itself — the far end is
+	* the CP/browser, so the body arrives inline and the reply streams back over the
+	* same WS. The message names its target agent explicitly (no trigger matching), so
+	* this normalizes the turn and hands it to the same dispatch path as any session:
+	* the turn is a REAL session (recorded to the transcript, visible in session/list),
+	* only its transport differs. Returns the ack: accepted + a fresh turnId that
+	* correlates the streamed webchat/output, or accepted:false / no_agent when the
+	* named agent isn't runnable here.
+	*/
+	handleWebchatMessage(m) {
+		const turnId = randomUUID();
+		const result = routeRules({
+			platform: "webchat",
+			channel: m.conversationId
+		}, this.mergedRules(), () => null, m.agentId);
+		if (!result || !this.agents.has(result.agentId)) {
+			this.log.warn(`webchat: no agent "${m.agentId}" on this daemon — rejecting turn`);
+			return {
+				accepted: false,
+				turnId,
+				reason: "no_agent"
+			};
+		}
+		const msg = {
+			msgId: `webchat:${m.conversationId}`,
+			traceId: turnId,
+			source: "user",
+			platform: "webchat",
+			channel: m.conversationId,
+			sender: {
+				id: m.user ?? "webchat",
+				isBot: false
+			},
+			text: m.text,
+			mentionedBots: [],
+			isDm: true,
+			trigger: "dm"
+		};
+		this.dispatch(result.agentId, msg, void 0, {
+			conversationId: m.conversationId,
+			turnId
+		}).catch((err) => this.log.error(`webchat dispatch failed for agent "${result.agentId}": ${formatErr(err)}`));
+		return {
+			accepted: true,
+			turnId
+		};
+	}
+	/** Handle a webchat conversation close (C→D `webchat/close`). No live resources are
+	*  bound per-conversation (the session TTL-closes like any other), so this is
+	*  currently just observability — the in-flight turn, if any, runs to completion. */
+	handleWebchatClose(m) {
+		this.log.debug(`webchat: conversation ${m.conversationId} closed by client`);
+	}
 	/** All of our own connections' bot identities (both `U…` user ids and `B…`
 	*  bot_ids), so we recognize self-echoes regardless of which field Slack sends. */
 	ownBotIdentities() {
@@ -84736,14 +84938,14 @@ var Daemon = class Daemon {
 		for (const cpRule of this.cpRouting?.effectiveRules() ?? []) if (!this.resolveCpAgent(cpRule.agentId)) out.add(cpRule.agentId);
 		return [...out];
 	}
-	async dispatch(agentId, msg, integrationId) {
+	async dispatch(agentId, msg, integrationId, webchat) {
 		if (this.draining || this.drainingAgents.has(agentId)) {
 			this.log.debug(`dispatch: skipped for agent "${agentId}" (draining)`);
 			return null;
 		}
 		const conv = new OutputConverger(this.agents.get(agentId).output.mode);
 		const rec = new TranscriptRecorder();
-		const replyConn = msg.headless ? void 0 : this.replyConnFor(agentId, integrationId);
+		const replyConn = msg.headless || webchat ? void 0 : this.replyConnFor(agentId, integrationId);
 		const wasRunning = this.hostStarts.has(agentId);
 		const statusThread = msg.thread ?? msg.msgId;
 		const key = sessionKey(msg.platform, msg.channel, statusThread, agentId);
@@ -84770,13 +84972,18 @@ var Daemon = class Daemon {
 			conn: replyConn,
 			applyChain: Promise.resolve(),
 			done,
-			resolveDone
+			resolveDone,
+			...webchat ? { webchat: {
+				...webchat,
+				index: 0,
+				replyText: ""
+			} } : {}
 		};
 		this.pending.set(sessionId, p);
 		try {
 			const host = await this.ensureHostAsync(agentId);
 			if (!wasRunning) replyConn?.setStatus(msg.channel, statusThread, "is thinking…");
-			const { usage } = await host.prompt(sessionId, blocks);
+			const { stopReason, usage } = await host.prompt(sessionId, blocks);
 			if (usage) this.store.setTokenUsage(key, {
 				totalTokens: usage.totalTokens,
 				inputTokens: usage.inputTokens,
@@ -84799,8 +85006,25 @@ var Daemon = class Daemon {
 				this.log.debug(`usage report emit failed (session ${sessionId}): ${err.message}`);
 			}
 			this.clearIdle(p);
-			const link = this.cfg.webAppUrl ? `${this.cfg.webAppUrl.replace(/\/$/, "")}/sessions/${sessionId}` : void 0;
-			for (const action of conv.onFinal(link)) this.enqueueApply(p, action);
+			if (p.webchat) {
+				if (p.webchat.replyText.trim()) this.store.appendTranscript({
+					channel: p.channel,
+					thread: statusThread,
+					ts: String(Date.now()),
+					sender: agentId,
+					kind: "text",
+					text: p.webchat.replyText
+				});
+				this.cpClient?.emitWebchatDone({
+					conversationId: p.webchat.conversationId,
+					turnId: p.webchat.turnId,
+					...stopReason ? { stopReason } : {},
+					...usage?.totalTokens !== void 0 ? { usage: { used: usage.totalTokens } } : {}
+				});
+			} else {
+				const link = this.cfg.webAppUrl ? `${this.cfg.webAppUrl.replace(/\/$/, "")}/sessions/${sessionId}` : void 0;
+				for (const action of conv.onFinal(link)) this.enqueueApply(p, action);
+			}
 			for (const ev of rec.onFinal()) this.recordEvent(agentId, msg.channel, statusThread, ev);
 			await p.applyChain;
 		} finally {
@@ -84921,10 +85145,68 @@ var Daemon = class Daemon {
 			costCurrency: update.cost?.currency ?? void 0
 		});
 		if (update?.sessionUpdate === "session_info_update" && update.title !== void 0) this.store.setSessionTitle(p.sessionKey, update.title);
-		for (const action of p.conv.onUpdate(update)) this.enqueueApply(p, action);
-		this.armIdle(p);
+		if (p.webchat) this.emitWebchatUpdate(p, update);
+		else {
+			for (const action of p.conv.onUpdate(update)) this.enqueueApply(p, action);
+			this.armIdle(p);
+		}
 		for (const ev of p.rec.onUpdate(update)) this.recordEvent(p.agentId, p.channel, p.statusThread, ev);
 	}
+	/**
+	* Map one ACP SessionUpdate to a WebchatEvent and stream it to the CP as a
+	* `webchat/output` EVT (webchat's "send"). Only the streamable chunk kinds map;
+	* usage/plan/session_info are handled elsewhere or dropped. A single event whose
+	* inline text would blow the 256 KiB frame cap is split across multiple chunks,
+	* each with its own monotonic `index`.
+	*/
+	emitWebchatUpdate(p, update) {
+		const wc = p.webchat;
+		const emit = (event) => {
+			this.cpClient?.emitWebchatOutput({
+				conversationId: wc.conversationId,
+				turnId: wc.turnId,
+				index: wc.index++,
+				event
+			});
+		};
+		switch (update?.sessionUpdate) {
+			case "agent_message_chunk": {
+				const text = update.content?.type === "text" ? update.content.text ?? "" : "";
+				if (text) {
+					wc.replyText += text;
+					for (const t of chunkText(text)) emit({
+						kind: "message",
+						text: t
+					});
+				}
+				return;
+			}
+			case "agent_thought_chunk": {
+				const text = update.content?.text ?? "";
+				if (text) for (const t of chunkText(text)) emit({
+					kind: "thinking",
+					text: t
+				});
+				return;
+			}
+			case "tool_call":
+				emit({
+					kind: "tool_call",
+					toolCallId: String(update.toolCallId ?? ""),
+					title: String(update.title ?? update.toolCallId ?? "tool"),
+					status: String(update.status ?? "pending")
+				});
+				return;
+			case "tool_call_update":
+				emit({
+					kind: "tool_update",
+					toolCallId: String(update.toolCallId ?? ""),
+					status: String(update.status ?? "")
+				});
+				return;
+			default: return;
+		}
+	}
 	/** Persist one internal activity event (tool/reasoning). Ordered by row `seq`, so its
 	*  `ts` is just a wall-clock stamp for display — never used for replay/sorting. */
 	recordEvent(agentId, channel, thread, ev) {
@@ -85333,6 +85615,8 @@ var Daemon = class Daemon {
 			sessionRead: createSessionReader(this.store, (agentId) => this.replyConnFor(agentId)?.workspaceUrl),
 			workspaceRead: createWorkspaceReader((id) => this.agents.get(id)?.workspace.path),
 			workspaceGit: createWorkspaceGit((id) => this.agents.get(id)?.workspace.path),
+			onWebchatMessage: (m) => this.handleWebchatMessage(m),
+			onWebchatClose: (m) => this.handleWebchatClose(m),
 			clock: systemClock,
 			connect: () => ClientTransport.dial(url),
 			log: this.log