@cardstack/boxel-cli 0.9.0 → 0.10.0-unstable.0

package/bundled-test-harness/assets/room-C7tKd02X.js

@@ -0,0 +1,1008 @@
+import { r as __exportAll, s as __toESM, t as __commonJSMin } from "./chunk-Rp0pCe6z.js";
+import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { $n as APP_BOXEL_TOOL_REQUESTS_KEY, Bn as APP_BOXEL_LLM_MODE, Kn as APP_BOXEL_REALM_SERVER_EVENT_MSGTYPE, Po as isCardInstance, Rn as APP_BOXEL_DEBUG_MESSAGE_EVENT_TYPE, Vn as APP_BOXEL_MESSAGE_MSGTYPE, _r as getToolDefinitions, br as isToolResultRelType, dr as LEGACY_APP_BOXEL_COMMAND_RESULT_EVENT_TYPE, er as APP_BOXEL_TOOL_RESULT_EVENT_TYPE, jn as APP_BOXEL_ACTIVE_LLM, ms as logger, qn as APP_BOXEL_REASONING_CONTENT_KEY, vr as getToolRequests } from "./runtime-common-ClpqhbwG.js";
+import { y as rri } from "./paths-BYHDgqsT.js";
+import { F as difference } from "./lodash-DnaZ_rzx.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { r as service } from "./service-LFpJ8EEP.js";
+import { n as registerDestructor } from "./destroyable-mdLYRn_o.js";
+import { t as isTesting } from "./runtime-9O0mNd7j.js";
+import { n as buildTask } from "./async-arrow-runtime-STsj7E8Y.js";
+import { n as Resource } from "./dist-B-fYvxfL.js";
+import { a as TrackedMap } from "./dist-B9tGPKZz.js";
+import { n as tracked, t as cached } from "./tracking-800VJb8b.js";
+import { r as timeout } from "./dist-DEVZvbin.js";
+import { t as buildWaiter } from "./dist-CSQ-y1Ft.js";
+import { n as readStopState } from "./stop-DKx-M3jV.js";
+import { n as RoomMember, t as MessageBuilder } from "./message-builder-DYoZFsDh.js";
+import { a as peekSkillSource, i as loadSkillSource, n as getSkillSourceTools, r as isMarkdownSkillId } from "./skill-tools-NZxKP9oK.js";
+import { t as Mutex } from "./mutex-Dhahglk8.js";
+import { i as usedLLMsFromEvents } from "./pickable-models-0K0eyoK_.js";
+var eventemitter3_default = (/* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var has = Object.prototype.hasOwnProperty;
+	var prefix = "~";
+	/**
+	* Constructor to create a storage for our `EE` objects.
+	* An `Events` instance is a plain object whose properties are event names.
+	*
+	* @constructor
+	* @private
+	*/
+	function Events() {}
+	if (Object.create) {
+		Events.prototype = Object.create(null);
+		if (!new Events().__proto__) prefix = false;
+	}
+	/**
+	* Representation of a single event listener.
+	*
+	* @param {Function} fn The listener function.
+	* @param {*} context The context to invoke the listener with.
+	* @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+	* @constructor
+	* @private
+	*/
+	function EE(fn, context, once) {
+		this.fn = fn;
+		this.context = context;
+		this.once = once || false;
+	}
+	/**
+	* Add a listener for a given event.
+	*
+	* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn The listener function.
+	* @param {*} context The context to invoke the listener with.
+	* @param {Boolean} once Specify if the listener is a one-time listener.
+	* @returns {EventEmitter}
+	* @private
+	*/
+	function addListener(emitter, event, fn, context, once) {
+		if (typeof fn !== "function") throw new TypeError("The listener must be a function");
+		var listener = new EE(fn, context || emitter, once);
+		var evt = prefix ? prefix + event : event;
+		if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+		else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+		else emitter._events[evt] = [emitter._events[evt], listener];
+		return emitter;
+	}
+	/**
+	* Clear event by name.
+	*
+	* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	* @param {(String|Symbol)} evt The Event name.
+	* @private
+	*/
+	function clearEvent(emitter, evt) {
+		if (--emitter._eventsCount === 0) emitter._events = new Events();
+		else delete emitter._events[evt];
+	}
+	/**
+	* Minimal `EventEmitter` interface that is molded against the Node.js
+	* `EventEmitter` interface.
+	*
+	* @constructor
+	* @public
+	*/
+	function EventEmitter() {
+		this._events = new Events();
+		this._eventsCount = 0;
+	}
+	/**
+	* Return an array listing the events for which the emitter has registered
+	* listeners.
+	*
+	* @returns {Array}
+	* @public
+	*/
+	EventEmitter.prototype.eventNames = function eventNames() {
+		var names = [];
+		var events;
+		var name;
+		if (this._eventsCount === 0) return names;
+		for (name in events = this._events) if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+		if (Object.getOwnPropertySymbols) return names.concat(Object.getOwnPropertySymbols(events));
+		return names;
+	};
+	/**
+	* Return the listeners registered for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @returns {Array} The registered listeners.
+	* @public
+	*/
+	EventEmitter.prototype.listeners = function listeners(event) {
+		var evt = prefix ? prefix + event : event;
+		var handlers = this._events[evt];
+		if (!handlers) return [];
+		if (handlers.fn) return [handlers.fn];
+		for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) ee[i] = handlers[i].fn;
+		return ee;
+	};
+	/**
+	* Return the number of listeners listening to a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @returns {Number} The number of listeners.
+	* @public
+	*/
+	EventEmitter.prototype.listenerCount = function listenerCount(event) {
+		var evt = prefix ? prefix + event : event;
+		var listeners = this._events[evt];
+		if (!listeners) return 0;
+		if (listeners.fn) return 1;
+		return listeners.length;
+	};
+	/**
+	* Calls each of the listeners registered for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @returns {Boolean} `true` if the event had listeners, else `false`.
+	* @public
+	*/
+	EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+		var evt = prefix ? prefix + event : event;
+		if (!this._events[evt]) return false;
+		var listeners = this._events[evt];
+		var len = arguments.length;
+		var args;
+		var i;
+		if (listeners.fn) {
+			if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+			switch (len) {
+				case 1: return listeners.fn.call(listeners.context), true;
+				case 2: return listeners.fn.call(listeners.context, a1), true;
+				case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+				case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+				case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+				case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+			}
+			for (i = 1, args = new Array(len - 1); i < len; i++) args[i - 1] = arguments[i];
+			listeners.fn.apply(listeners.context, args);
+		} else {
+			var length = listeners.length;
+			var j;
+			for (i = 0; i < length; i++) {
+				if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+				switch (len) {
+					case 1:
+						listeners[i].fn.call(listeners[i].context);
+						break;
+					case 2:
+						listeners[i].fn.call(listeners[i].context, a1);
+						break;
+					case 3:
+						listeners[i].fn.call(listeners[i].context, a1, a2);
+						break;
+					case 4:
+						listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+						break;
+					default:
+						if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) args[j - 1] = arguments[j];
+						listeners[i].fn.apply(listeners[i].context, args);
+				}
+			}
+		}
+		return true;
+	};
+	/**
+	* Add a listener for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn The listener function.
+	* @param {*} [context=this] The context to invoke the listener with.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.on = function on(event, fn, context) {
+		return addListener(this, event, fn, context, false);
+	};
+	/**
+	* Add a one-time listener for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn The listener function.
+	* @param {*} [context=this] The context to invoke the listener with.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.once = function once(event, fn, context) {
+		return addListener(this, event, fn, context, true);
+	};
+	/**
+	* Remove the listeners of a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn Only remove the listeners that match this function.
+	* @param {*} context Only remove the listeners that have this context.
+	* @param {Boolean} once Only remove one-time listeners.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+		var evt = prefix ? prefix + event : event;
+		if (!this._events[evt]) return this;
+		if (!fn) {
+			clearEvent(this, evt);
+			return this;
+		}
+		var listeners = this._events[evt];
+		if (listeners.fn) {
+			if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) clearEvent(this, evt);
+		} else {
+			for (var i = 0, events = [], length = listeners.length; i < length; i++) if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) events.push(listeners[i]);
+			if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+			else clearEvent(this, evt);
+		}
+		return this;
+	};
+	/**
+	* Remove all listeners, or those of the specified event.
+	*
+	* @param {(String|Symbol)} [event] The event name.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+		var evt;
+		if (event) {
+			evt = prefix ? prefix + event : event;
+			if (this._events[evt]) clearEvent(this, evt);
+		} else {
+			this._events = new Events();
+			this._eventsCount = 0;
+		}
+		return this;
+	};
+	EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+	EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+	EventEmitter.prefixed = prefix;
+	EventEmitter.EventEmitter = EventEmitter;
+	if ("undefined" !== typeof module) module.exports = EventEmitter;
+})))(), 1)).default;
+//#endregion
+//#region app/lib/matrix-classes/room.ts
+function decodeWireData(content) {
+	if (content?.data && typeof content.data === "string") try {
+		content.data = JSON.parse(content.data);
+	} catch (e) {
+		console.error("Failed to decode event content.data; leaving it encoded", e);
+	}
+}
+var Room = class {
+	static {
+		decorateFieldV2(this.prototype, "_events", [tracked], function() {
+			return [];
+		});
+	}
+	#_events = (initializeDeferredDecorator(this, "_events"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "_roomState", [tracked]);
+	}
+	#_roomState = (initializeDeferredDecorator(this, "_roomState"), void 0);
+	constructor(roomId) {
+		this.roomId = roomId;
+	}
+	mutex = new Mutex();
+	emitter = new eventemitter3_default();
+	waitForNextEvent() {
+		return new Promise((resolve) => {
+			this.emitter.once("event.added", resolve);
+		});
+	}
+	get events() {
+		return this._events;
+	}
+	get name() {
+		return this._roomState?.events.get("m.room.name")?.get("")?.event.content?.name;
+	}
+	get memberIds() {
+		return [...(this._roomState?.events.get("m.room.member")?.values() ?? []).map((ev) => ev.event.state_key)].filter((id) => id !== void 0);
+	}
+	static {
+		decorateMethodV2(this.prototype, "memberIds", [cached]);
+	}
+	hasActiveMember(userId) {
+		let membership = (this._roomState?.events.get("m.room.member")?.get(userId))?.event.content?.membership;
+		return membership === "join" || membership === "invite";
+	}
+	notifyRoomStateUpdated(rs) {
+		this._roomState = rs;
+	}
+	get hasRoomState() {
+		return this._roomState !== void 0;
+	}
+	get skillsConfig() {
+		const content = this._roomState?.events.get("app.boxel.room.skills")?.get("")?.event.content ?? {
+			enabledSkillCards: [],
+			disabledSkillCards: []
+		};
+		return {
+			enabledSkillCards: content.enabledSkillCards ? content.enabledSkillCards : [],
+			disabledSkillCards: content.disabledSkillCards ? content.disabledSkillCards : [],
+			toolDefinitionFileDefs: getToolDefinitions(content) ?? []
+		};
+	}
+	get activeLLMEventContent() {
+		return (this._roomState?.events.get(APP_BOXEL_ACTIVE_LLM)?.get("")?.event)?.content;
+	}
+	get activeLLM() {
+		return this.activeLLMEventContent?.model;
+	}
+	get activeInputModalities() {
+		return this.activeLLMEventContent?.inputModalities;
+	}
+	get activeLLMMode() {
+		let event = this._roomState?.events.get(APP_BOXEL_LLM_MODE)?.get("")?.event;
+		return event && event.content?.mode ? event.content.mode : "ask";
+	}
+	addEvent(event, oldEventId) {
+		let { event_id: eventId, state_key: stateKey } = event;
+		eventId = eventId ?? stateKey;
+		decodeWireData(event.content);
+		if (!eventId) throw new Error(`bug: event ID is undefined for event ${JSON.stringify(event, null, 2)}`);
+		let matchingEvents = this._events.filter((e) => e.event_id === eventId || e.event_id === oldEventId);
+		if (matchingEvents.length > 1) throw new Error(`bug: ${matchingEvents.length} events with the same event_id(s): ${eventId}, ${oldEventId}, expected a maximum of 1`);
+		if (matchingEvents.length === 0) {
+			this._events = [...this._events ?? [], event];
+			return;
+		}
+		let eventToReplace = matchingEvents[0];
+		let eventIndex = this._events.indexOf(eventToReplace);
+		this._events[eventIndex] = event;
+		this._events = [...this._events];
+		this.emitter.emit("event.added");
+	}
+};
+//#endregion
+//#region app/resources/room.ts
+var room_exports = /* @__PURE__ */ __exportAll({
+	RoomResource: () => RoomResource,
+	getAggregatedReplacement: () => getAggregatedReplacement,
+	getRoom: () => getRoom
+});
+var IN_FLIGHT_EVENT_STATUSES = new Set([
+	"encrypting",
+	"queued",
+	"sending",
+	"sent"
+]);
+var responseStreamLog = logger("matrix:response-stream");
+var roomProcessingWaiter = buildWaiter("room-resource:processing");
+var RoomResource = class extends Resource {
+	#skillIds = /* @__PURE__ */ new Set();
+	#hasRegisteredDestructor = false;
+	#responseStreamPreviewDisposer;
+	#lastPreviewSequence = /* @__PURE__ */ new Map();
+	_messageCache = new TrackedMap();
+	_nameEventsCache = new TrackedMap();
+	static {
+		decorateFieldV2(this.prototype, "_createEvent", [tracked]);
+	}
+	#_createEvent = (initializeDeferredDecorator(this, "_createEvent"), void 0);
+	_memberCache = new TrackedMap();
+	_isDisplayingViewCodeMap = new TrackedMap();
+	static {
+		decorateFieldV2(this.prototype, "matrixRoom", [tracked]);
+	}
+	#matrixRoom = (initializeDeferredDecorator(this, "matrixRoom"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "processing", [tracked]);
+	}
+	#processing = (initializeDeferredDecorator(this, "processing"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "roomId", [tracked]);
+	}
+	#roomId = (initializeDeferredDecorator(this, "roomId"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "llmBeingActivated", [tracked]);
+	}
+	#llmBeingActivated = (initializeDeferredDecorator(this, "llmBeingActivated"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "llmModeBeingActivated", [tracked]);
+	}
+	#llmModeBeingActivated = (initializeDeferredDecorator(this, "llmModeBeingActivated"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "matrixService", [service]);
+	}
+	#matrixService = (initializeDeferredDecorator(this, "matrixService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "operatorModeStateService", [service]);
+	}
+	#operatorModeStateService = (initializeDeferredDecorator(this, "operatorModeStateService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "toolService", [service]);
+	}
+	#toolService = (initializeDeferredDecorator(this, "toolService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "store", [service]);
+	}
+	#store = (initializeDeferredDecorator(this, "store"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "realm", [service]);
+	}
+	#realm = (initializeDeferredDecorator(this, "realm"), void 0);
+	modify(_positional, named) {
+		if (!named.roomId) return;
+		this.roomId = named.roomId;
+		this.processing = this.processRoomTask.perform(named.roomId);
+		if (!this.#hasRegisteredDestructor) {
+			this.#hasRegisteredDestructor = true;
+			this.#responseStreamPreviewDisposer = this.matrixService.onResponseStreamPreview((payload) => this.hydrateResponseStreamPreview(payload));
+			registerDestructor(this, () => this.teardown());
+		}
+	}
+	teardown() {
+		this.processRoomTask.cancelAll();
+		this.activateLLMTask.cancelAll();
+		this.activateLLMModeTask.cancelAll();
+		this.#responseStreamPreviewDisposer?.();
+		this.#responseStreamPreviewDisposer = void 0;
+		this.#lastPreviewSequence.clear();
+		for (let id of this.#skillIds ?? []) this.store.dropReference(id);
+		this.#skillIds.clear();
+		this._messageCache.clear();
+		this._nameEventsCache.clear();
+		this._memberCache.clear();
+		this._isDisplayingViewCodeMap.clear();
+		this._createEvent = void 0;
+		this.matrixRoom = void 0;
+		this.processing = void 0;
+		this.roomId = void 0;
+		this.llmBeingActivated = void 0;
+		this.llmModeBeingActivated = void 0;
+	}
+	get isProcessing() {
+		return this.processRoomTask.isRunning;
+	}
+	processingLastStartedAt = 0;
+	processingRestartWindowStartedAt = 0;
+	processingRestartsInWindow = 0;
+	notePerformForRestartTrace(roomId) {
+		if (!isTesting()) return;
+		let now = Date.now();
+		if (now - this.processingRestartWindowStartedAt > 1e3) {
+			if (this.processingRestartsInWindow > 20) console.log(`[room-processing-trace] processRoomTask restarted ${this.processingRestartsInWindow} times in the last second for room ${roomId}`);
+			this.processingRestartWindowStartedAt = now;
+			this.processingRestartsInWindow = 0;
+		}
+		this.processingRestartsInWindow++;
+	}
+	processRoomTask = buildTask(() => ({
+		context: this,
+		generator: function* (roomId) {
+			this.notePerformForRestartTrace(roomId);
+			this.processingLastStartedAt = Date.now();
+			let waiterToken = roomProcessingWaiter.beginAsync();
+			try {
+				this.matrixRoom = roomId ? yield this.matrixService.getRoomData(roomId) : void 0;
+				if (!this.matrixRoom) return;
+				let memberIds = this.matrixRoom.memberIds;
+				if (!memberIds || !memberIds.includes(this.matrixService.aiBotUserId)) return;
+				try {
+					yield this.loadSkills(this.matrixRoom.skillsConfig.enabledSkillCards);
+				} catch (e) {
+					console.warn(`Failed to load skills: ${e}`);
+				}
+				let index = this._messageCache.size;
+				for (let event of this.events) {
+					if (event.type === "app.boxel.compaction") {
+						this.updateMessageCompaction(event);
+						continue;
+					}
+					switch (event.type) {
+						case "m.room.member":
+							yield this.loadRoomMemberEvent(roomId, event);
+							break;
+						case "m.room.message":
+							if (this.isRealmServerEvent(event)) break;
+							else this.loadRoomMessage({
+								roomId,
+								event,
+								index
+							});
+							break;
+						case APP_BOXEL_DEBUG_MESSAGE_EVENT_TYPE:
+							this.loadRoomMessage({
+								roomId,
+								event,
+								index
+							});
+							break;
+						case APP_BOXEL_TOOL_RESULT_EVENT_TYPE:
+						case LEGACY_APP_BOXEL_COMMAND_RESULT_EVENT_TYPE:
+							this.updateMessageCommandResult({
+								roomId,
+								event,
+								index
+							});
+							break;
+						case "m.room.create":
+							yield this.loadRoomCreateEvent(event);
+							break;
+						case "m.room.name":
+							yield this.loadRoomNameEvent(event);
+							break;
+					}
+					this.matrixService.cacheContentHashIfNeeded(event);
+				}
+			} catch (e) {
+				throw new Error(`Error loading room ${e}`);
+			} finally {
+				roomProcessingWaiter.endAsync(waiterToken);
+			}
+		}
+	}), null, "processRoomTask", "restartable");
+	get messages() {
+		if (this.roomId == void 0) return [];
+		return [...this._messageCache.values()].filter((m) => m.roomId === this.roomId).filter((m) => !m.continuationOf).sort((a, b) => a.created.getTime() - b.created.getTime());
+	}
+	/**
+	* The message an event belongs to, which for an answer long enough to have
+	* been split across continuation events is the head of that chain — the one
+	* `messages` exposes, and the only one whose `body` is the whole answer. A
+	* caller holding a raw event id cannot use `messages.find` for this: the
+	* continuations are filtered out of that list, so every id but the first
+	* looks like an event with no message.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "messages", [cached]);
+	}
+	messageForEventId(eventId) {
+		let message = this._messageCache.get(eventId);
+		if (!message) return;
+		let seen = /* @__PURE__ */ new Set();
+		while (message?.continuationOf && !seen.has(message.continuationOf)) {
+			seen.add(message.continuationOf);
+			let parent = this._messageCache.get(message.continuationOf);
+			if (!parent) return;
+			message = parent;
+		}
+		return message;
+	}
+	/**
+	* Whether the user has stopped the assistant's loop, and which answers that
+	* stop hit (see `readStopState`). Read from the room's events rather than
+	* kept per tab, so every client and every reload agrees. The rule reads
+	* `events`, which puts a stop still being sent after every confirmed event:
+	* a stop's local echo carries this client's clock, which can disagree with
+	* the server's.
+	*/
+	get stopState() {
+		return readStopState(this.events, this.matrixService.aiBotUserId);
+	}
+	/**
+	* Whether the answer carrying this event is stopped now: Stop is not
+	* offered for it, and its results start no new turn. A click that asks for
+	* one of its calls to go ahead lifts this.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "stopState", [cached]);
+	}
+	isStopped(eventId) {
+		return this.stopState.stoppedMessageIds.has(eventId);
+	}
+	/**
+	* Whether a stop ever hit the answer carrying this event. Its tools that
+	* never got a result must not start on their own, however the loop was
+	* resumed since.
+	*/
+	wasEverStopped(eventId) {
+		return this.stopState.everStoppedMessageIds.has(eventId);
+	}
+	get members() {
+		if (this.roomId == void 0) return [];
+		return Array.from(this._memberCache.values()).filter((m) => m.roomId === this.roomId) ?? [];
+	}
+	static {
+		decorateMethodV2(this.prototype, "members", [cached]);
+	}
+	get invitedMembers() {
+		if (this.roomId == void 0) return [];
+		return this.members.filter((m) => m.membership === "invite" && m.roomId === this.roomId);
+	}
+	static {
+		decorateMethodV2(this.prototype, "invitedMembers", [cached]);
+	}
+	get joinedMembers() {
+		if (this.roomId == void 0) return [];
+		return this.members.filter((m) => m.membership === "join" && m.roomId === this.roomId);
+	}
+	static {
+		decorateMethodV2(this.prototype, "joinedMembers", [cached]);
+	}
+	get indexOfLastNonDebugMessage() {
+		for (let i = this.messages.length - 1; i >= 0; i--) if (this.messages[i].isDebugMessage !== true) return i;
+		return -1;
+	}
+	get rawEvents() {
+		return this.matrixRoom?.events ?? [];
+	}
+	get events() {
+		let inFlight = (event) => event.status != null && IN_FLIGHT_EVENT_STATUSES.has(event.status);
+		return [...this.rawEvents].sort((a, b) => {
+			let aInFlight = inFlight(a);
+			if (aInFlight !== inFlight(b)) return aInFlight ? 1 : -1;
+			if (aInFlight) return 0;
+			return a.origin_server_ts - b.origin_server_ts;
+		});
+	}
+	static {
+		decorateMethodV2(this.prototype, "events", [cached]);
+	}
+	async waitForNextEvent() {
+		return this.matrixRoom?.waitForNextEvent();
+	}
+	get allSkillFileDefs() {
+		let skillConfig = this.matrixRoom?.skillsConfig;
+		if (!skillConfig || !skillConfig.enabledSkillCards || !skillConfig.disabledSkillCards) return [];
+		const enabledSkillCards = skillConfig.enabledSkillCards || [];
+		const disabledSkillCards = skillConfig.disabledSkillCards || [];
+		const uniqueCardsMap = /* @__PURE__ */ new Map();
+		for (const card of enabledSkillCards) uniqueCardsMap.set(card.sourceUrl, card);
+		for (const card of disabledSkillCards) if (!uniqueCardsMap.has(card.sourceUrl)) uniqueCardsMap.set(card.sourceUrl, card);
+		return Array.from(uniqueCardsMap.values());
+	}
+	get skills() {
+		let result = [];
+		for (let skillCard of this.allSkillFileDefs) result.push({
+			cardId: skillCard.sourceUrl,
+			realmURL: this.realm.realmOf(rri(skillCard.sourceUrl)),
+			fileDef: skillCard,
+			isActive: this.matrixRoom?.skillsConfig.enabledSkillCards.map((enabledCard) => enabledCard.sourceUrl).includes(skillCard.sourceUrl) ?? false
+		});
+		return result;
+	}
+	get tools() {
+		let commands = [];
+		for (let skill of this.skills) {
+			if (!skill.isActive) continue;
+			let skillSource = peekSkillSource(this.store, skill.cardId);
+			if (skillSource) commands.push(...getSkillSourceTools(skillSource));
+		}
+		return commands;
+	}
+	get created() {
+		if (this._createEvent) {
+			let d = new Date(this._createEvent.origin_server_ts);
+			if (!isNaN(d.getTime())) return d;
+		}
+		return /* @__PURE__ */ new Date();
+	}
+	static {
+		decorateMethodV2(this.prototype, "created", [cached]);
+	}
+	get name() {
+		return this.matrixRoom?.name;
+	}
+	get lastActiveTimestamp() {
+		let eventsWithTime = this.events.filter((t) => t.origin_server_ts);
+		return eventsWithTime[eventsWithTime.length - 1]?.origin_server_ts ?? this.created.getTime();
+	}
+	static {
+		decorateMethodV2(this.prototype, "lastActiveTimestamp", [cached]);
+	}
+	get activeLLM() {
+		return this.llmBeingActivated ?? this.resolveActiveLLMKey() ?? this.defaultLLM;
+	}
+	get activeInputModalities() {
+		return this.matrixRoom?.activeInputModalities;
+	}
+	resolveActiveLLMKey() {
+		let eventContent = this.matrixRoom?.activeLLMEventContent;
+		if (!eventContent?.model) return;
+		let systemCard = this.matrixService.systemCard;
+		if (systemCard?.modelConfigurations) {
+			let match = systemCard.modelConfigurations.find((config) => config.modelId === eventContent.model && (config.reasoningEffort ?? void 0) === (eventContent.reasoningEffort ?? void 0));
+			if (match?.id) return match.id;
+			let fallbackMatch = systemCard.modelConfigurations.find((config) => config.modelId === eventContent.model);
+			if (fallbackMatch?.id) return fallbackMatch.id;
+		}
+		return eventContent.model;
+	}
+	get defaultLLM() {
+		let systemCard = this.matrixService.systemCard;
+		return systemCard?.defaultModelConfiguration?.id ?? systemCard?.modelConfigurations?.[0]?.id ?? "anthropic/claude-haiku-5.5";
+	}
+	get usedLLMs() {
+		return usedLLMsFromEvents(this.events);
+	}
+	static {
+		decorateMethodV2(this.prototype, "usedLLMs", [cached]);
+	}
+	get isActivatingLLM() {
+		return this.activateLLMTask.isRunning;
+	}
+	activateLLMTask = buildTask(() => ({
+		context: this,
+		generator: function* (key) {
+			yield this.processing;
+			if (this.activeLLM === key) return;
+			this.llmBeingActivated = key;
+			try {
+				if (!this.matrixRoom) throw new Error("matrixRoom is required to activate LLM");
+				let modelId = key;
+				let config;
+				let systemCard = this.matrixService.systemCard;
+				if (systemCard?.modelConfigurations) {
+					let modelConfig = systemCard.modelConfigurations.find((c) => c.id === key);
+					if (modelConfig?.modelId) {
+						modelId = modelConfig.modelId;
+						config = {
+							toolsSupported: modelConfig.toolsSupported,
+							reasoningEffort: modelConfig.reasoningEffort,
+							inputModalities: modelConfig.inputModalities
+						};
+					}
+				}
+				yield this.matrixService.sendActiveLLMEvent(this.matrixRoom.roomId, modelId, config);
+				let remainingRetries = 20;
+				while (this.matrixRoom.activeLLM !== modelId && remainingRetries > 0) {
+					yield timeout(50);
+					remainingRetries--;
+				}
+				if (remainingRetries === 0) throw new Error("Failed to activate LLM");
+			} finally {
+				this.llmBeingActivated = void 0;
+			}
+		}
+	}), null, "activateLLMTask", "restartable");
+	get activeLLMMode() {
+		return this.llmModeBeingActivated ?? this.matrixRoom?.activeLLMMode ?? "ask";
+	}
+	get llmModeEvents() {
+		return this.events.filter((event) => event.type === APP_BOXEL_LLM_MODE);
+	}
+	/**
+	* Get the LLM mode that was active when a given message was created.
+	*
+	* Matrix `origin_server_ts` has millisecond resolution, so a message and a
+	* mode transition can share a timestamp; a bare timestamp comparison cannot
+	* tell whether such a transition happened just before or just after the
+	* message. `events` is a stable sort on `origin_server_ts`, so for
+	* equal timestamps it preserves room (insertion) order. Walking it up to the
+	* message and tracking the last mode transition seen yields the mode in
+	* effect when the message arrived, regardless of same-millisecond ties.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "llmModeEvents", [cached]);
+	}
+	getActiveLLMModeForMessage(messageEventId) {
+		let activeMode = "ask";
+		let foundMessage = false;
+		for (let event of this.events) {
+			if (event.event_id === messageEventId) {
+				foundMessage = true;
+				break;
+			}
+			if (event.type === "app.boxel.llm-mode") activeMode = event.content?.mode ?? "ask";
+		}
+		if (!foundMessage) return "ask";
+		return activeMode;
+	}
+	get isActivatingLLMMode() {
+		return this.activateLLMModeTask.isRunning;
+	}
+	activateLLMModeTask = buildTask(() => ({
+		context: this,
+		generator: function* (mode) {
+			yield this.processing;
+			if (this.activeLLMMode === mode) return;
+			this.llmModeBeingActivated = mode;
+			try {
+				if (!this.matrixRoom) throw new Error("matrixRoom is required to activate LLM mode");
+				yield this.matrixService.sendLLMModeEvent(this.matrixRoom.roomId, mode);
+				let remainingRetries = 20;
+				while (this.matrixRoom.activeLLMMode !== mode && remainingRetries > 0) {
+					yield timeout(50);
+					remainingRetries--;
+				}
+				if (remainingRetries === 0) throw new Error("Failed to activate LLM mode");
+			} finally {
+				this.llmModeBeingActivated = void 0;
+			}
+		}
+	}), null, "activateLLMModeTask", "restartable");
+	async loadRoomMemberEvent(roomId, event) {
+		let roomMemberArgs = {
+			userId: event.state_key,
+			displayName: event.content.displayname,
+			membership: event.content.membership,
+			membershipDateTime: new Date(event.origin_server_ts),
+			membershipInitiator: event.sender
+		};
+		this.upsertRoomMember({
+			roomId,
+			...roomMemberArgs
+		});
+	}
+	isRealmServerEvent(event) {
+		return event.content.msgtype === APP_BOXEL_REALM_SERVER_EVENT_MSGTYPE;
+	}
+	async loadSkill(doc) {
+		let cardId = doc.data.id;
+		if (!cardId) throw new Error(`SKill card document has no id, this should not happen: ${JSON.stringify(doc, null, 2)}`);
+		let skillCard = await this.store.get(cardId);
+		if (isCardInstance(skillCard)) return skillCard;
+		else return;
+	}
+	async loadEnabledSkill(skillCardFileDef) {
+		try {
+			if (isMarkdownSkillId(skillCardFileDef.sourceUrl)) return await loadSkillSource(this.store, skillCardFileDef.sourceUrl) ? skillCardFileDef.sourceUrl : void 0;
+			let cardDoc = await this.matrixService.downloadCardFileDef(skillCardFileDef);
+			return (await this.loadSkill(cardDoc))?.id;
+		} catch (e) {
+			console.warn(`Failed to load skill ${skillCardFileDef.sourceUrl} for room ${this.roomId}: ${e}`);
+			return;
+		}
+	}
+	async loadSkills(skillCardFileDefs) {
+		let skillIds = [];
+		for (let skillCardFileDef of skillCardFileDefs) {
+			let skillId = await this.loadEnabledSkill(skillCardFileDef);
+			if (skillId) skillIds.push(skillId);
+		}
+		let oldReferences = [...this.#skillIds ?? []];
+		let newReferences = [...skillIds ?? []];
+		this.#skillIds = new Set(skillIds);
+		let referencesToDrop = difference(oldReferences, newReferences);
+		for (let id of referencesToDrop) this.store.dropReference(id);
+		let referencesToAdd = difference(newReferences, oldReferences);
+		for (let id of referencesToAdd) this.store.addReference(id, isMarkdownSkillId(id) ? { type: "file-meta" } : void 0);
+	}
+	loadRoomMessage({ roomId, event, index }) {
+		let effectiveEventId = this.getEffectiveEventId(event);
+		event = getAggregatedReplacement(event);
+		let clientGeneratedId = "clientGeneratedId" in event.content ? event.content.clientGeneratedId : void 0;
+		let message = this._messageCache.get(effectiveEventId) ?? (clientGeneratedId ? this._messageCache.get(clientGeneratedId) : void 0);
+		if (message?.isStreamingOfEventFinished) {
+			let usage = event.content.data?.usage;
+			if (usage && !message.usage) message.setUsage(usage);
+		}
+		if (!message?.isStreamingOfEventFinished) {
+			let author = this.upsertRoomMember({
+				roomId,
+				userId: event.sender
+			});
+			let messageBuilder = new MessageBuilder(event, getOwner(this), {
+				roomId,
+				effectiveEventId,
+				author,
+				index,
+				events: this.events,
+				skills: this.skills
+			});
+			if (!message) {
+				message = messageBuilder.buildMessage();
+				this._messageCache.set(message.clientGeneratedId ?? effectiveEventId, message);
+			} else messageBuilder.updateMessage(message);
+		}
+		if (message.continuationOf) {
+			let continuedFromMessage = this._messageCache.get(message.continuationOf);
+			if (continuedFromMessage) continuedFromMessage.continuedInMessage = message;
+		}
+	}
+	hydrateResponseStreamPreview(payload) {
+		if (!payload || payload.roomId !== this.roomId) return;
+		let message = this._messageCache.get(payload.parentEventId);
+		if (!message || message.isStreamingOfEventFinished) {
+			if (message?.isStreamingOfEventFinished) this.#lastPreviewSequence.delete(payload.parentEventId);
+			return;
+		}
+		let lastSequence = this.#lastPreviewSequence.get(payload.parentEventId) ?? -1;
+		if (payload.sequence <= lastSequence) return;
+		this.#lastPreviewSequence.set(payload.parentEventId, payload.sequence);
+		this.applyResponseStreamPreview(message, payload);
+	}
+	applyResponseStreamPreview(message, payload) {
+		try {
+			let author = this.upsertRoomMember({
+				roomId: payload.roomId,
+				userId: this.matrixService.aiBotUserId
+			});
+			new MessageBuilder({
+				type: "m.room.message",
+				event_id: payload.parentEventId,
+				room_id: payload.roomId,
+				sender: this.matrixService.aiBotUserId,
+				origin_server_ts: message.created.getTime(),
+				content: {
+					msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+					body: payload.body,
+					[APP_BOXEL_REASONING_CONTENT_KEY]: payload.reasoning,
+					[APP_BOXEL_TOOL_REQUESTS_KEY]: payload.toolRequests,
+					isStreamingFinished: false
+				}
+			}, getOwner(this), {
+				roomId: payload.roomId,
+				effectiveEventId: payload.parentEventId,
+				author,
+				index: message.index ?? 0,
+				events: this.events,
+				skills: this.skills
+			}).updateMessage(message);
+		} catch (err) {
+			responseStreamLog.debug(`dropped response-stream preview (seq ${payload.sequence}) for ${payload.parentEventId}`, err);
+		}
+	}
+	updateMessageCommandResult({ roomId, event, index }) {
+		let messageEventWithCommand = this.events.find((e) => e.type === "m.room.message" && getToolRequests(e.content)?.some((cr) => cr.id === event.content.commandRequestId));
+		if (!messageEventWithCommand) return;
+		let messageCacheKey = this.getEffectiveEventId(messageEventWithCommand);
+		let message = this._messageCache.get(messageCacheKey);
+		if (!message) return;
+		let author = this.upsertRoomMember({
+			roomId,
+			userId: event.sender
+		});
+		new MessageBuilder(messageEventWithCommand, getOwner(this), {
+			roomId,
+			effectiveEventId: messageCacheKey,
+			author,
+			index,
+			events: this.events,
+			skills: this.skills,
+			toolResultEvent: event
+		}).updateMessageCommandResult(message);
+	}
+	updateMessageCompaction(event) {
+		let { status, responseEventId, summary } = event.content ?? {};
+		if (event.sender !== this.matrixService.aiBotUserId || !responseEventId || status !== "running" && status !== "done" && status !== "failed") return;
+		let message = this._messageCache.get(responseEventId);
+		if (message) message.compaction = {
+			status,
+			summary: typeof summary === "string" ? summary : void 0
+		};
+	}
+	getEffectiveEventId(event) {
+		if (!("m.relates_to" in event.content)) return event.event_id;
+		return event.content["m.relates_to"]?.rel_type === "m.replace" || isToolResultRelType(event.content["m.relates_to"]?.rel_type) ? event.content["m.relates_to"].event_id : event.event_id;
+	}
+	async loadRoomNameEvent(event) {
+		if (!this._nameEventsCache.has(event.event_id)) this._nameEventsCache.set(event.event_id, event);
+	}
+	async loadRoomCreateEvent(event) {
+		this._createEvent = event;
+	}
+	upsertRoomMember({ roomId, userId, displayName, membership, membershipDateTime, membershipInitiator }) {
+		let member;
+		member = this._memberCache.get(userId);
+		if (member?.membershipDateTime && membershipDateTime && member.membershipDateTime.getTime() > Number(membershipDateTime)) return member;
+		if (!member) member = new RoomMember({
+			userId,
+			roomId
+		});
+		if (displayName) member.displayName = displayName;
+		if (membership) member.membership = membership;
+		if (membershipDateTime != null) member.membershipDateTime = new Date(membershipDateTime);
+		if (membershipInitiator) member.membershipInitiator = membershipInitiator;
+		this._memberCache.set(userId, member);
+		return member;
+	}
+	isDisplayingCode(toolRequest) {
+		return this._isDisplayingViewCodeMap.get(toolRequest.id) ?? false;
+	}
+	toggleViewCode(toolRequest) {
+		this._isDisplayingViewCodeMap.set(toolRequest.id, !this.isDisplayingCode(toolRequest));
+	}
+};
+function getAggregatedReplacement(event) {
+	let finalRawEvent;
+	const originalEventId = event.event_id;
+	let replacedRawEvent = event.unsigned?.["m.relations"]?.["m.replace"];
+	if (!event.content["m.relates_to"]?.rel_type && replacedRawEvent) {
+		finalRawEvent = replacedRawEvent;
+		finalRawEvent.event_id = originalEventId;
+		decodeWireData(finalRawEvent.content);
+	} else finalRawEvent = event;
+	return finalRawEvent;
+}
+function getRoom(parent, roomId, deps) {
+	return RoomResource.from(parent, () => ({ named: {
+		roomId: roomId(),
+		deps: deps()
+	} }));
+}
+//#endregion
+export { decodeWireData as a, Room as i, getRoom as n, room_exports as r, getAggregatedReplacement as t };