@agentconnect.md/daemon 1.0.0-rc.233 → 1.0.0-rc.235

package/dist/{acp-host-CF3j4yST.js → acp-host-D9z7hKHJ.js}

@@ -197,6 +197,23 @@ object({
 });
 /** The all-zero UUID used when a frame is malformed past the point of reading `id`. */
 const NIL_UUID = "00000000-0000-0000-0000-000000000000";
+/**
+* Builds the envelope schema for one frame `type` — the `type` literal plus the
+* typed payload — so a wire's discriminated union infers `payload` precisely.
+* Shared by the daemon↔CP union (`frame.ts`) and the relay wire unions
+* (`frames/relay-cp.ts` / `frames/relay-daemon.ts`), which are deliberately
+* SEPARATE unions over the same envelope shape (shared-bot-relay.md §8).
+*/
+function frameSchema(type, payload) {
+	return object({
+		v: literal(1),
+		id: string().uuid(),
+		ts: string().datetime(),
+		type: literal(type),
+		corr: string().uuid().optional(),
+		payload
+	});
+}
 //#endregion
 //#region ../protocol/dist/frames/auth.js
 /**
@@ -1246,6 +1263,23 @@ const WebchatStatus = object({
 	fastModeAvailable: boolean().optional(),
 	sessionId: string().optional()
 });
+const WebchatOutput = object({
+	conversationId: string().uuid(),
+	turnId: string().uuid(),
+	index: number().int(),
+	event: WebchatEvent.optional(),
+	status: WebchatStatus.optional()
+}).refine((o) => o.event !== void 0 || o.status !== void 0, { message: "WebchatOutput must carry event and/or status" });
+const WebchatDone = object({
+	conversationId: string().uuid(),
+	turnId: string().uuid(),
+	stopReason: string().optional(),
+	usage: object({
+		used: number().int().optional(),
+		cost: number().optional()
+	}).optional(),
+	error: string().optional()
+});
 //#endregion
 //#region ../protocol/dist/frame.js
 /**
@@ -1275,23 +1309,8 @@ const FRAME_SCHEMAS = {
 	"agent/scope-denied": AgentScopeDenied,
 	"webchat/message": WebchatMessage,
 	"webchat/ack": WebchatAck,
-	"webchat/output": object({
-		conversationId: string().uuid(),
-		turnId: string().uuid(),
-		index: number().int(),
-		event: WebchatEvent.optional(),
-		status: WebchatStatus.optional()
-	}).refine((o) => o.event !== void 0 || o.status !== void 0, { message: "WebchatOutput must carry event and/or status" }),
-	"webchat/done": object({
-		conversationId: string().uuid(),
-		turnId: string().uuid(),
-		stopReason: string().optional(),
-		usage: object({
-			used: number().int().optional(),
-			cost: number().optional()
-		}).optional(),
-		error: string().optional()
-	}),
+	"webchat/output": WebchatOutput,
+	"webchat/done": WebchatDone,
 	"webchat/close": object({ conversationId: string().uuid() }),
 	"webchat/set-model": object({
 		conversationId: string().uuid(),
@@ -1571,6 +1590,114 @@ function encode(frame) {
 	return JSON.stringify(frame);
 }
 //#endregion
+//#region ../protocol/dist/frames/relay-daemon.js
+/**
+* relay↔daemon frames (`rd/*`) — shared-bot-relay.md §7.2.
+*
+* The daemon dials OUT to every relay in its roster (one WS per (daemon, relay)
+* pair, multiplexing every source). This wire CARRIES MESSAGE CONTENT — it is
+* the ingress data plane — so nothing on it is ever logged with its payload.
+*
+* Direction per frame:
+*  - `rd/hello` (+ `rd/hello/ok`)  D→R REQ / R→D REP — authenticate the dial-in
+*  - `rd/msg`                      R→D REQ — one inbound item, already routed
+*  - `rd/ack`                      D→R REP — receipt (+ webchat turn verdict)
+*  - `rd/chat`                     D→R EVT — webchat output stream back to the
+*                                  browser (webchat is the one BIDIRECTIONAL
+*                                  source: its far end hangs off the relay)
+*
+* Milestone A carries the webchat slice only; `im` (shared bot) and `hook`
+* (webhook) members join the `rd/msg` union with milestone B.
+*/
+/** Subprotocol negotiated on the relay↔daemon socket. */
+const RELAY_DAEMON_SUBPROTOCOL = "agentconnect.rd.v1";
+/** The canonical path the relay mounts its daemon-facing `rd/*` server at, and
+*  the daemon appends to a roster `daemonUrl` origin when dialing (mirrors the
+*  daemon↔CP `/daemon/ws` convention). A roster url already ending in it is used
+*  verbatim. */
+const RELAY_DAEMON_WS_PATH = "/rd/ws";
+const RdHello = object({
+	apiKey: string().min(1),
+	daemonId: string().uuid()
+});
+const RdHelloOk = object({ relayId: string().uuid() });
+const RelayWebchatOp = discriminatedUnion("op", [
+	object({
+		op: literal("turn"),
+		text: string(),
+		user: string().optional()
+	}),
+	object({
+		op: literal("set_model"),
+		model: string()
+	}),
+	object({
+		op: literal("set_effort"),
+		effort: string()
+	}),
+	object({
+		op: literal("set_permission_mode"),
+		permissionMode: string()
+	}),
+	object({
+		op: literal("set_fast"),
+		fastMode: boolean()
+	}),
+	object({ op: literal("cancel") }),
+	object({ op: literal("close") })
+]);
+const RdMsg = discriminatedUnion("source", [object({
+	source: literal("webchat"),
+	agentId: string().uuid(),
+	sessionKey: string().min(1),
+	msgId: string().min(1),
+	chatId: string().uuid(),
+	payload: RelayWebchatOp
+})]);
+const RdAck = object({
+	msgId: string(),
+	accepted: boolean(),
+	turnId: string().uuid().optional(),
+	reason: string().optional()
+});
+const RdChatEvent = discriminatedUnion("kind", [object({
+	kind: literal("output"),
+	output: WebchatOutput
+}), object({
+	kind: literal("done"),
+	done: WebchatDone
+})]);
+/** `type` string → payload schema for the relay↔daemon wire. */
+const RELAY_DAEMON_SCHEMAS = {
+	"rd/hello": RdHello,
+	"rd/hello/ok": RdHelloOk,
+	"rd/msg": RdMsg,
+	"rd/ack": RdAck,
+	"rd/chat": object({
+		chatId: string().uuid(),
+		seq: number().int(),
+		event: RdChatEvent
+	}),
+	error: ErrorFrame
+};
+Object.keys(RELAY_DAEMON_SCHEMAS);
+discriminatedUnion("type", [
+	frameSchema("rd/hello", RELAY_DAEMON_SCHEMAS["rd/hello"]),
+	frameSchema("rd/hello/ok", RELAY_DAEMON_SCHEMAS["rd/hello/ok"]),
+	frameSchema("rd/msg", RELAY_DAEMON_SCHEMAS["rd/msg"]),
+	frameSchema("rd/ack", RELAY_DAEMON_SCHEMAS["rd/ack"]),
+	frameSchema("rd/chat", RELAY_DAEMON_SCHEMAS["rd/chat"]),
+	frameSchema("error", RELAY_DAEMON_SCHEMAS["error"])
+]);
+/** Decode one relay↔daemon wire frame (envelope + typed payload). */
+function decodeRelayDaemonFrame(text) {
+	return decodeEnvelopeWith(RELAY_DAEMON_SCHEMAS, text);
+}
+/** Build a relay↔daemon frame with a compile-time-typed payload. */
+function buildRelayDaemonFrame(type, payload, opts = {}) {
+	return buildEnvelopeRaw(type, payload, opts);
+}
+//#endregion
 //#region ../protocol/dist/git-url.js
 /**
 * Git repo address helpers, shared by the CP (normalize on write) and the
@@ -10694,6 +10821,6 @@ var AcpHost = class {
 	}
 };
 //#endregion
-export { cachedRuntimeNames as _, initGitInjection as a, simpleGit as c, buildEnvelope as d, decodeEnvelope as f, RESERVED_MCP_SERVER_NAME as g, MEMORY_INDEX as h, prepareWorkspace as i, isFrame as l, MAX_FRAME_BYTES as m, installedRuntimes as n, probeGitVersion as o, encode as p, prefetchWorkspace as r, sessionGitEnv as s, AcpHost as t, normalizeGitUrl as u, cachedRuntimeVersions as v, resolveRuntimes as y };
+export { resolveRuntimes as C, cachedRuntimeVersions as S, encode as _, initGitInjection as a, RESERVED_MCP_SERVER_NAME as b, simpleGit as c, RELAY_DAEMON_SUBPROTOCOL as d, RELAY_DAEMON_WS_PATH as f, decodeEnvelope as g, buildEnvelope as h, prepareWorkspace as i, isFrame as l, decodeRelayDaemonFrame as m, installedRuntimes as n, probeGitVersion as o, buildRelayDaemonFrame as p, prefetchWorkspace as r, sessionGitEnv as s, AcpHost as t, normalizeGitUrl as u, MAX_FRAME_BYTES as v, cachedRuntimeNames as x, MEMORY_INDEX as y };
 
-//# sourceMappingURL=acp-host-CF3j4yST.js.map
+//# sourceMappingURL=acp-host-D9z7hKHJ.js.map