@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.5

package/bundled-test-harness/assets/tools-test-Dn1LYsXp.js

@@ -1,3204 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Bn as APP_BOXEL_CONTINUATION_OF_CONTENT_KEY, Br as testRealmURL, Jo as isCardInstance, Kn as APP_BOXEL_MESSAGE_MSGTYPE, Rc as Deferred, Un as APP_BOXEL_EXTERNAL_FIELDS_KEY, Wn as APP_BOXEL_HAS_CONTINUATION_CONTENT_KEY, Wr as AI_BOT_EXECUTOR, Yr as buildToolFunctionNameFromResolvedRef, ar as APP_BOXEL_TOOL_REQUESTS_KEY, cr as APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE, lr as APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE, or as APP_BOXEL_TOOL_RESULT_EVENT_TYPE, rr as APP_BOXEL_STOP_GENERATING_EVENT_TYPE, sr as APP_BOXEL_TOOL_RESULT_REL_TYPE, tr as APP_BOXEL_RESPONSE_STREAM_EVENT_TYPE } from "./runtime-common-BTaLJEw-.js";
-import { T as rri } from "./paths-C9-NYXnM.js";
-import { q as skillCardRef } from "./constants-Icc0nFW-.js";
-import { t as config } from "./environment-DIUJgBKt.js";
-import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
-import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
-import { n as Submodes } from "./submode-switcher-BpDa9Rui.js";
-import "./component-BJO47HTh.js";
-import { t as Component } from "./dist-CkA1rgqO.js";
-import "./template-factory-ds9s0u8l.js";
-import { t as OperatorModeContainer } from "./container-Cqcwrd-m.js";
-import { t as STOPPED_TOOL_CALL_REASON } from "./stop-lrhqMDul.js";
-import { M as waitUntil, T as settled, a as find, d as click, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { D as realmConfigCardJSON, Et as percySnapshot, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, g as delay, lt as setupRenderingTest, o as addSkillToAiAssistant, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { A as field, H as linksTo, U as linksToMany, a as CardDef, l as FieldDef, s as Component$1, w as contains } from "./card-api-Cc8uZunB.js";
-import { t as string_default } from "./string-5IAMEUit.js";
-import { n as renderComponent } from "./render-component-B15Z0e2v.js";
-//#region tests/integration/components/ai-assistant-panel/e75beeb704.css
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-//#endregion
-//#region tests/integration/components/ai-assistant-panel/tools-test.gts
-function registeredRealmPrefixes() {
-	let { virtualNetwork } = getService("network");
-	return Object.fromEntries(virtualNetwork.knownRealms().map((prefix) => [prefix, virtualNetwork.toURLHref(prefix)]));
-}
-function menuItem(label) {
-	return [...document.querySelectorAll("[data-test-pretui-menu-panel] [role=\"menuitem\"]")].find((row) => row.textContent?.trim() === label);
-}
-(0, import_qunit.module)("Integration | ai-assistant-panel | tools", function(hooks) {
-	const realmName = "Operator Mode Workspace";
-	const readOnlyRealmName = "Read Only Workspace";
-	const readOnlyRealmURL = "http://test-realm/read-only/";
-	const searchCardsToolName = buildToolFunctionNameFromResolvedRef({
-		module: "@cardstack/boxel-host/commands/search-cards",
-		name: "SearchCardsByTypeAndTitleTool"
-	});
-	let loader;
-	let operatorModeStateService;
-	setupRenderingTest(hooks);
-	setupOperatorModeStateCleanup(hooks);
-	hooks.beforeEach(function() {
-		loader = getService("loader-service").loader;
-	});
-	setupLocalIndexing(hooks);
-	setupRealmCacheTeardown(hooks);
-	setupOnSave(hooks);
-	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL, readOnlyRealmURL],
-		realmPermissions: {
-			[testRealmURL]: ["read", "write"],
-			[readOnlyRealmURL]: ["read"]
-		},
-		autostart: true,
-		now: (() => {
-			let clock = new Date(2024, 8, 19).getTime();
-			return () => clock += 10;
-		})()
-	});
-	let { createAndJoinRoom, simulateRemoteMessage, simulateToDeviceEvent, getRoomEvents } = mockMatrixUtils;
-	let noop = () => {};
-	hooks.beforeEach(async function() {
-		operatorModeStateService = getService("operator-mode-state-service");
-		class Pet extends CardDef {
-			static displayName = "Pet";
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(string_default, { computeVia: function() {
-						return this.name;
-					} });
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-			static fitted = class Fitted extends Component$1 {
-				static {
-					setComponentTemplate(templateFactory({
-						"id": "IHMPzHnr",
-						"block": "[[[10,\"h3\"],[15,\"data-test-pet\",[30,1,[\"name\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"name\"]],null,null,null],[1,\"\\n\"],[13]],[\"@model\",\"@fields\"],[]]",
-						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-						"isStrictMode": true
-					}), this);
-				}
-			};
-		}
-		class Address extends FieldDef {
-			static displayName = "Address";
-			static {
-				decorateFieldV2(this.prototype, "city", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#city = (initializeDeferredDecorator(this, "city"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "country", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#country = (initializeDeferredDecorator(this, "country"), void 0);
-			static embedded = class Embedded extends Component$1 {
-				static {
-					setComponentTemplate(templateFactory({
-						"id": "0uTOjQm9",
-						"block": "[[[10,0],[14,\"data-test-address\",\"\"],[12],[1,\"\\n  \"],[10,\"h3\"],[15,\"data-test-city\",[30,1,[\"city\"]]],[12],[1,\"\\n    \"],[8,[30,2,[\"city\"]],null,null,null],[1,\"\\n  \"],[13],[1,\"\\n  \"],[10,\"h3\"],[15,\"data-test-country\",[30,1,[\"country\"]]],[12],[1,\"\\n    \"],[8,[30,2,[\"country\"]],null,null,null],[1,\"\\n  \"],[13],[1,\"\\n\"],[13]],[\"@model\",\"@fields\"],[]]",
-						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-						"isStrictMode": true
-					}), this);
-				}
-			};
-		}
-		class Person extends CardDef {
-			static displayName = "Person";
-			static {
-				decorateFieldV2(this.prototype, "firstName", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "pet", [field], function() {
-					return linksTo(Pet);
-				});
-			}
-			#pet = (initializeDeferredDecorator(this, "pet"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "friends", [field], function() {
-					return linksToMany(Pet);
-				});
-			}
-			#friends = (initializeDeferredDecorator(this, "friends"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "firstLetterOfTheName", [field], function() {
-					return contains(string_default, { computeVia: function() {
-						return this.firstName[0];
-					} });
-				});
-			}
-			#firstLetterOfTheName = (initializeDeferredDecorator(this, "firstLetterOfTheName"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(string_default, { computeVia: function() {
-						return this.firstName;
-					} });
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "address", [field], function() {
-					return contains(Address);
-				});
-			}
-			#address = (initializeDeferredDecorator(this, "address"), void 0);
-			static isolated = class Isolated extends Component$1 {
-				static {
-					setComponentTemplate(templateFactory({
-						"id": "86ylgsLt",
-						"block": "[[[10,\"h2\"],[15,\"data-test-person\",[30,1,[\"firstName\"]]],[14,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"],[12],[1,\"\\n  \"],[8,[30,2,[\"firstName\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[1,\"\\n\"],[13],[1,\"\\n\"],[10,2],[15,\"data-test-first-letter-of-the-name\",[30,1,[\"firstLetterOfTheName\"]]],[14,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"],[12],[1,\"\\n  \"],[8,[30,2,[\"firstLetterOfTheName\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[1,\"\\n\"],[13],[1,\"\\nPet:\\n\"],[10,0],[14,0,\"pet-container\"],[14,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"],[12],[1,\"\\n  \"],[8,[30,2,[\"pet\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[1,\"\\n\"],[13],[1,\"\\nFriends:\\n\"],[8,[30,2,[\"friends\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[1,\"\\n\"],[10,0],[14,\"data-test-addresses\",\"\"],[14,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"],[12],[1,\"Address: \"],[8,[30,2,[\"address\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[13],[1,\"\\n\"]],[\"@model\",\"@fields\"],[]]",
-						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-						"isStrictMode": true
-					}), this);
-				}
-			};
-		}
-		let petMango = new Pet({ name: "Mango" });
-		let petJackie = new Pet({ name: "Jackie" });
-		await withCachedRealmSetup(async () => {
-			await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				contents: {
-					"address.gts": { Address },
-					"hello.txt": "Hello, world!",
-					"person.gts": { Person },
-					"pet.gts": { Pet },
-					"Pet/mango.json": petMango,
-					"Pet/jackie.json": petJackie,
-					"Person/fadhlan.json": new Person({
-						firstName: "Fadhlan",
-						address: new Address({
-							city: "Bandung",
-							country: "Indonesia"
-						}),
-						pet: petMango
-					}),
-					"Person/burcu.json": new Person({
-						firstName: "Burcu",
-						friends: [petJackie, petMango]
-					}),
-					"Person/mickey.json": new Person({ firstName: "Mickey" }),
-					"Person/justin.json": new Person({ firstName: "Justin" }),
-					"Person/ian.json": new Person({ firstName: "Ian" }),
-					"Person/matic.json": new Person({ firstName: "Matic" }),
-					"Person/buck.json": new Person({ firstName: "Buck" }),
-					"Person/hassan.json": new Person({ firstName: "Hassan" }),
-					"Skill/boxel-environment.json": { data: {
-						attributes: {
-							title: "Boxel Environment",
-							description: "Test environment skill",
-							instructions: "Test skill card for environment commands",
-							commands: [
-								{
-									codeRef: {
-										name: "SearchCardsByTypeAndTitleTool",
-										module: "@cardstack/boxel-host/commands/search-cards"
-									},
-									requiresApproval: false
-								},
-								{
-									codeRef: {
-										name: "SearchCardsByQueryTool",
-										module: "@cardstack/boxel-host/commands/search-cards"
-									},
-									requiresApproval: false
-								},
-								{
-									codeRef: {
-										name: "default",
-										module: "@cardstack/boxel-host/commands/read-file-for-ai-assistant"
-									},
-									requiresApproval: false
-								},
-								{
-									codeRef: {
-										name: "default",
-										module: "@cardstack/boxel-host/commands/read-card-for-ai-assistant"
-									},
-									requiresApproval: false
-								}
-							]
-						},
-						meta: { adoptsFrom: skillCardRef }
-					} },
-					"realm.json": realmConfigCardJSON({ name: realmName })
-				}
-			});
-			await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				realmURL: readOnlyRealmURL,
-				contents: {
-					"pet.gts": `
-            import { contains, field, CardDef } from "@cardstack/base/card-api";
-            import StringField from "@cardstack/base/string";
-            export class Pet extends CardDef {
-              static displayName = 'Pet';
-              @field name = contains(StringField);
-            }
-          `,
-					"person.gts": `
-            import { contains, field, linksTo, CardDef } from "@cardstack/base/card-api";
-            import StringField from "@cardstack/base/string";
-            import { Pet } from "./pet";
-            export class Person extends CardDef {
-              static displayName = 'Person';
-              @field firstName = contains(StringField);
-              @field pet = linksTo(Pet);
-            }
-          `,
-					"Person/ian.json": { data: {
-						type: "card",
-						attributes: { firstName: "Ian" },
-						relationships: { pet: { data: {
-							type: "card",
-							id: `${readOnlyRealmURL}Pet/rose`
-						} } },
-						meta: { adoptsFrom: {
-							module: "./person",
-							name: "Person"
-						} }
-					} },
-					"Pet/rose.json": { data: {
-						type: "card",
-						attributes: { name: "Rose" },
-						meta: { adoptsFrom: {
-							module: "./pet",
-							name: "Pet"
-						} }
-					} },
-					"realm.json": realmConfigCardJSON({ name: readOnlyRealmName })
-				}
-			});
-		});
-	});
-	function setCardInOperatorModeState(cardURL, format = "isolated") {
-		operatorModeStateService.restore({ stacks: cardURL ? [[{
-			id: cardURL,
-			format
-		}]] : [[]] });
-	}
-	async function openAiAssistant() {
-		await waitFor("[data-test-open-ai-assistant]");
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-settled]");
-		let roomId = document.querySelector("[data-test-room]")?.getAttribute("data-test-room");
-		if (!roomId) throw new Error("Expected a room ID");
-		return roomId;
-	}
-	async function renderAiAssistantPanel(id) {
-		setCardInOperatorModeState(id);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		return await openAiAssistant();
-	}
-	const TOOL_RESULT_TIMEOUT_MS = 1e4;
-	async function waitForToolResult(selector = "[data-test-tool-result-header]") {
-		let startedAt = performance.now();
-		try {
-			await waitFor(selector, { timeout: TOOL_RESULT_TIMEOUT_MS });
-		} catch (e) {
-			let applyButtons = [...document.querySelectorAll("[data-test-tool-call-apply]")].map((el) => el.getAttribute("data-test-tool-call-apply"));
-			console.error(`[tool-result-wait] no ${selector} after ${Math.round(performance.now() - startedAt)}ms; messages=${document.querySelectorAll("[data-test-message-idx]").length}; applyStates=${JSON.stringify(applyButtons)} (a tool that reached "applied" points at the result card load; see any [tool-result-card] lines)`);
-			throw e;
-		}
-		console.log(`[tool-result-wait] ${selector} after ${Math.round(performance.now() - startedAt)}ms`);
-	}
-	(0, import_qunit.test)("it allows chat commands to change cards in the stack", async function(assert) {
-		assert.expect(4);
-		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`);
-		await waitFor("[data-test-person]");
-		assert.dom("[data-test-boxel-card-header-title]").hasText("Person - Fadhlan");
-		assert.dom("[data-test-person]").hasText("Fadhlan");
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			body: "i am the body",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "change-cards-in-stack",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Dave" } }
-				} })
-			}],
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: "patch1"
-			}
-		});
-		await waitFor("[data-test-tool-call-apply]");
-		this.onSave((_, json) => {
-			if (typeof json === "string") throw new Error("expected JSON save data");
-			assert.strictEqual(json.data.attributes?.firstName, "Dave");
-		});
-		await click("[data-test-pretui-tool-gate-action=\"apply\"]");
-		await waitFor("[data-test-tool-call-card-idle]");
-		assert.dom("[data-test-person]").hasText("Dave");
-	});
-	(0, import_qunit.test)("when a command is being prepared, apply button is shown in preparing state", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		let initialEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: false
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first name to Evie",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: false,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
-				name: "patchCardInstance"
-			}],
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: initialEventId
-			}
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		assert.dom("[data-test-message-idx]").exists({ count: 1 });
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists();
-	});
-	(0, import_qunit.test)("it does not display the streaming indicator when ai bot sends a command", async function(assert) {
-		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
-			body: "i am the body",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "fb8fef81-2142-4861-a902-d5614b0aea52",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Dave" } }
-				} })
-			}]
-		});
-		await waitFor("[data-test-message-idx=\"0\"]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-ai-avatar]").doesNotHaveClass("ai-avatar-animated", "ai bot patch message does not have a spinner");
-	});
-	(0, import_qunit.test)("when command is done streaming, apply button is shown in ready state", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		let initialEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: false
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first names",
-			format: "org.matrix.custom.html",
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
-				name: "patchCardInstance"
-			}],
-			isStreamingFinished: false,
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: initialEventId
-			}
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		assert.dom("[data-test-message-idx]").exists({ count: 1 });
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists();
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first names",
-			format: "org.matrix.custom.html",
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}, {
-				id: "f2da5504-b92f-480a-986a-56ec606d240e",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/hassan`,
-					patch: { attributes: { firstName: "Ivana" } }
-				} })
-			}],
-			isStreamingFinished: false,
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: initialEventId
-			}
-		});
-		await settled();
-		assert.dom("[data-test-message-idx]").exists({ count: 1 });
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists({ count: 2 }, "each call still arriving is a streaming row");
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first names",
-			format: "org.matrix.custom.html",
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}, {
-				id: "f2da5504-b92f-480a-986a-56ec606d240e",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/hassan`,
-					patch: { attributes: { firstName: "Ivana" } }
-				} })
-			}],
-			isStreamingFinished: true,
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: initialEventId
-			}
-		});
-		await settled();
-		assert.dom("[data-test-message-idx]").exists({ count: 1 });
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").doesNotExist("every call has arrived");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"ready\"]").exists({ count: 2 });
-	});
-	(0, import_qunit.test)("after command is executed, a command result event will be dispatched", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first name to Evie",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "result-event-dispatch",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}]
-		});
-		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
-		assert.strictEqual(commandResultEvents.length, 0, "command result event is not dispatched");
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
-		await waitFor("[data-test-tool-call-card-idle]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists();
-		commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
-		assert.strictEqual(commandResultEvents.length, 1, "command result event is dispatched");
-		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).context, {
-			agentId: getService("matrix-service").agentId,
-			submode: "interact",
-			debug: false,
-			openCardIds: ["http://test-realm/test/Person/fadhlan"],
-			realmPrefixes: registeredRealmPrefixes(),
-			realmUrl: "http://test-realm/test/",
-			realmPermissions: {
-				canRead: true,
-				canWrite: true
-			}
-		}, "command result event contains the context");
-	});
-	(0, import_qunit.test)("after search command is executed, a command result event is dispatched", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			body: "Changing first name to Evie",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "search-result-dispatch",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}]
-		});
-		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE);
-		assert.strictEqual(commandResultEvents.length, 0, "command result event is not dispatched");
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
-		await waitFor("[data-test-tool-call-card-idle]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists();
-		commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE);
-		assert.strictEqual(commandResultEvents.length, 1, "command result event is dispatched");
-		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).context, {
-			agentId: getService("matrix-service").agentId,
-			submode: "interact",
-			debug: false,
-			openCardIds: ["http://test-realm/test/Person/fadhlan"],
-			realmPrefixes: registeredRealmPrefixes(),
-			realmUrl: "http://test-realm/test/",
-			realmPermissions: {
-				canRead: true,
-				canWrite: true
-			}
-		}, "command result event contains the context");
-	});
-	(0, import_qunit.test)("it can search for card instances that is of the same card type as the card shared", async function(assert) {
-		let roomId = await renderAiAssistantPanel(`${testRealmURL}Pet/mango.json`);
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Search for the following card",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "search1",
-				name: searchCardsToolName,
-				arguments: JSON.stringify({
-					description: "Searching for card",
-					attributes: { type: {
-						module: `${testRealmURL}pet`,
-						name: "Pet"
-					} }
-				})
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitForToolResult();
-		assert.dom("[data-test-ai-message-content]").containsText("Search for the following card");
-		assert.dom("[data-test-ai-message-content] [data-test-pretui-tool-row-toggle]").exists({ count: 1 });
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-result-header]").containsText("SearchCardsByTypeAndTitle", "the result's meta line names the call");
-		assert.dom(".result-list li").exists({ count: 2 });
-		assert.dom(".result-list li:nth-child(1)").containsText("Jackie");
-		assert.dom(".result-list li:nth-child(2)").containsText("Mango");
-		assert.dom("[data-test-toggle-show-button]").doesNotExist();
-	});
-	(0, import_qunit.test)("it can search for card instances based upon title of card", async function(assert) {
-		let roomId = await renderAiAssistantPanel(`${testRealmURL}Pet/mango.json`);
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Search for the following card",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "search1",
-				name: searchCardsToolName,
-				arguments: JSON.stringify({
-					description: "Searching for card",
-					attributes: { cardTitle: "Mango" }
-				})
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitForToolResult();
-		assert.dom("[data-test-ai-message-content]").containsText("Search for the following card");
-		assert.dom("[data-test-ai-message-content] [data-test-pretui-tool-row-toggle]").exists({ count: 1 });
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-boxel-tool-call-result]").exists("the search results card shows in the row");
-		assert.dom(".result-list li:nth-child(1)").containsText("Mango");
-		assert.dom("[data-test-toggle-show-button]").doesNotExist();
-	});
-	(0, import_qunit.test)("toggle more search results", async function(assert) {
-		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan.json`);
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Search for the following card",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "721c8c78-d8c1-4cc1-a7e9-51d2d3143e4d",
-				name: searchCardsToolName,
-				arguments: JSON.stringify({
-					description: "Searching for card",
-					attributes: { type: {
-						module: `${testRealmURL}person`,
-						name: "Person"
-					} }
-				})
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitForToolResult();
-		let resultCard = find("[data-test-message-idx=\"0\"] [data-test-boxel-tool-call-result]");
-		let cardStyle = window.getComputedStyle(resultCard);
-		assert.notStrictEqual(cardStyle.color, cardStyle.backgroundColor, "result body text contrasts with its background");
-		assert.dom(".result-list li:nth-child(6)").doesNotExist();
-		assert.dom("[data-test-toggle-show-button]").containsText("Show 3 more results");
-		await click("[data-test-toggle-show-button]");
-		await waitFor(".result-list li", { count: 8 });
-		assert.dom("[data-test-toggle-show-button]").containsText("See Less");
-		assert.dom(".result-list li:nth-child(1)").containsText("Buck");
-		assert.dom(".result-list li:nth-child(2)").containsText("Burcu");
-		assert.dom(".result-list li:nth-child(3)").containsText("Fadhlan");
-		assert.dom(".result-list li:nth-child(4)").containsText("Hassan");
-		assert.dom(".result-list li:nth-child(5)").containsText("Ian");
-		assert.dom(".result-list li:nth-child(6)").containsText("Justin");
-		assert.dom(".result-list li:nth-child(7)").containsText("Matic");
-		assert.dom(".result-list li:nth-child(8)").containsText("Mickey");
-		await click("[data-test-toggle-show-button]");
-		assert.dom(".result-list li:nth-child(1)").containsText("Buck");
-		assert.dom(".result-list li:nth-child(2)").containsText("Burcu");
-		assert.dom(".result-list li:nth-child(3)").containsText("Fadhlan");
-		assert.dom(".result-list li:nth-child(4)").containsText("Hassan");
-		assert.dom(".result-list li:nth-child(5)").containsText("Ian");
-		assert.dom(".result-list li:nth-child(6)").doesNotExist();
-	});
-	(0, import_qunit.test)("it can copy search results card to workspace", async function(assert) {
-		const id = `${testRealmURL}Person/fadhlan`;
-		const roomId = await renderAiAssistantPanel(`${id}.json`);
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		const toolArgs = {
-			description: "Search for Person cards",
-			attributes: { type: {
-				module: `${testRealmURL}person`,
-				name: "Person"
-			} }
-		};
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Search for the following card",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "fd4515fb-ed4d-4005-9782-4e844d7d4d9c",
-				name: searchCardsToolName,
-				arguments: JSON.stringify(toolArgs)
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitForToolResult();
-		assert.dom(`[data-test-stack-card="${id}"]`).exists();
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-boxel-tool-call-result]").exists("the search results card shows in the row");
-		let resultListItem = "[data-test-result-list] > li";
-		assert.dom(`${resultListItem}:nth-child(1)`).containsText("Buck");
-		assert.dom(`${resultListItem}:nth-child(5)`).containsText("Ian");
-		const rightStackItem = "[data-test-operator-mode-stack=\"1\"] [data-test-stack-card-index=\"0\"]";
-		assert.dom(rightStackItem).doesNotExist();
-		await click("[data-test-tool-result-container] [data-test-more-options-button]");
-		await click(menuItem("Copy to Workspace"));
-		assert.dom(`${rightStackItem} [data-test-boxel-card-header-title]`).hasText("Search Results - Search Results");
-		const savedCard = `[data-test-card="${document.querySelector(rightStackItem)?.getAttribute("data-stack-card")}"] [data-test-tool-result-isolated]`;
-		assert.dom(`${savedCard} header`).hasText("Search Results 8 Results");
-		assert.dom(`${savedCard} [data-test-boxel-field]`).exists({ count: 2 });
-		assert.dom(`${savedCard} [data-test-boxel-field]:nth-child(1)`).hasText(`Description Query: { "type": { "module": "http://test-realm/test/person", "name": "Person" } }`);
-		resultListItem = `${savedCard} ${resultListItem}`;
-		assert.dom(resultListItem).exists({ count: 8 });
-		assert.dom(`${resultListItem}:nth-child(1)`).containsText("Buck");
-		assert.dom(`${resultListItem}:nth-child(6)`).containsText("Justin");
-		assert.dom(`${resultListItem}:nth-child(8)`).containsText("Mickey");
-	});
-	(0, import_qunit.test)("copy to workspace menu item is shown for writable realm", async function(assert) {
-		const roomId = await renderAiAssistantPanel(`${`${testRealmURL}Person/fadhlan`}.json`);
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		const toolArgs = {
-			description: "Search for Person cards",
-			attributes: { type: {
-				module: `${testRealmURL}person`,
-				name: "Person"
-			} }
-		};
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Search for the following card",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "9a5b7422-87de-4a93-9f07-9b7c40b75b1e",
-				name: searchCardsToolName,
-				arguments: JSON.stringify(toolArgs)
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitForToolResult();
-		await click("[data-test-tool-result-container] [data-test-more-options-button]");
-		assert.ok(menuItem("Copy to Workspace"), "the menu offers the copy");
-	});
-	(0, import_qunit.test)("copy to workspace menu item is hidden for read-only realm", async function(assert) {
-		const roomId = await renderAiAssistantPanel(`${`${readOnlyRealmURL}Person/ian`}.json`);
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		const toolArgs = {
-			description: "Search for Person cards",
-			attributes: { type: {
-				module: `${testRealmURL}person`,
-				name: "Person"
-			} }
-		};
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Search for the following card",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "6c6e2d73-8e09-4b44-a0d9-688f36b73be8",
-				name: searchCardsToolName,
-				arguments: JSON.stringify(toolArgs)
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitForToolResult();
-		assert.dom("[data-test-tool-result-container] [data-test-more-options-button]").doesNotExist();
-		assert.notOk(menuItem("Copy to Workspace"), "no copy is offered");
-	});
-	(0, import_qunit.test)("it can copy search results card to workspace (no cards in stack)", async function(assert) {
-		const id = `${testRealmURL}Person/fadhlan`;
-		const roomId = await renderAiAssistantPanel(`${id}.json`);
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		const toolArgs = {
-			description: "Search for Person cards",
-			attributes: { type: {
-				module: `${testRealmURL}person`,
-				name: "Person"
-			} }
-		};
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Search for the following card",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "ffd1a3d0-0bd4-491a-a907-b96ec9d8902c",
-				name: searchCardsToolName,
-				arguments: JSON.stringify(toolArgs)
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitForToolResult();
-		assert.dom(`[data-test-stack-card="${id}"]`).exists();
-		await click("[data-test-close-button]");
-		assert.dom(`[data-test-stack-card="${id}"]`).doesNotExist();
-		assert.dom(`[data-test-stack-card="${testRealmURL}index"]`).exists();
-		await click("[data-test-close-button]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-boxel-tool-call-result]").exists("the search results card shows in the row");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-toggle-show-button]").containsText("Show 3 more results");
-		let resultListItem = "[data-test-result-list] > li";
-		assert.dom(`${resultListItem}:nth-child(1)`).containsText("Buck");
-		assert.dom(`${resultListItem}:nth-child(5)`).containsText("Ian");
-		const stackItem = "[data-test-operator-mode-stack=\"0\"] [data-test-stack-card-index=\"0\"]";
-		assert.dom(stackItem).doesNotExist();
-		await click("[data-test-tool-result-container] [data-test-more-options-button]");
-		await click(menuItem("Copy to Workspace"));
-		assert.dom(`${stackItem} [data-test-boxel-card-header-title]`).hasText("Search Results - Search Results");
-		const savedCard = `[data-test-card="${document.querySelector(stackItem)?.getAttribute("data-stack-card")}"] [data-test-tool-result-isolated]`;
-		assert.dom(`${savedCard} header`).hasText("Search Results 8 Results");
-		assert.dom(`${savedCard} [data-test-boxel-field]`).exists({ count: 2 });
-		assert.dom(`${savedCard} [data-test-boxel-field]:nth-child(1)`).hasText(`Description Query: { "type": { "module": "http://test-realm/test/person", "name": "Person" } }`);
-		resultListItem = `${savedCard} ${resultListItem}`;
-		assert.dom(resultListItem).exists({ count: 8 });
-		assert.dom(`${resultListItem}:nth-child(1)`).containsText("Buck");
-		assert.dom(`${resultListItem}:nth-child(6)`).containsText("Justin");
-		assert.dom(`${resultListItem}:nth-child(8)`).containsText("Mickey");
-	});
-	(0, import_qunit.test)("it maintains status of View Code panel as additional events stream in", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		simulateRemoteMessage(createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		}), "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first name to Evie",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "view-code-panel-status",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}]
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		assert.dom("[data-test-ai-message-content] [data-test-pretui-code]").doesNotExist("View Code panel should not yet be open");
-		await click("[data-test-pretui-tool-row-toggle]");
-		assert.dom("[data-test-ai-message-content] [data-test-pretui-code]").exists("View Code panel should be open");
-		await fillIn("[data-test-message-field]", "Asking a question about what I saw in the proposed code...");
-		await click("[data-test-send-message-btn]");
-		assert.dom("[data-test-ai-message-content] [data-test-pretui-code]").exists("View Code panel should remain open");
-		await percySnapshot(assert);
-	});
-	(0, import_qunit.test)("\"Hide Info\" collapses the code area even after the message re-mounts while expanded", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		simulateRemoteMessage(createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		}), "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first name to Evie",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "hide-info-height",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}]
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		await click("[data-test-pretui-tool-row-toggle]");
-		await waitFor("[data-test-pretui-code]");
-		await click("[data-test-close-ai-assistant]");
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-pretui-code]");
-		await settled();
-		await click("[data-test-pretui-tool-row-toggle]");
-		assert.dom("[data-test-pretui-code]").doesNotExist("code editor is removed after Hide Info");
-		let codeBlockSelector = "[data-test-tool-call-id=\"hide-info-height\"] [data-test-tool-code-block]";
-		assert.dom(codeBlockSelector).exists("tool code block element exists");
-		let codeBlock = find(codeBlockSelector);
-		assert.strictEqual(codeBlock.style.height, "", "no inline height is left behind so the block collapses to its header-only height");
-	});
-	(0, import_qunit.test)("expanding a tall tool call does not leave an empty gap below the code", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		let attributes = Object.fromEntries(Array.from({ length: 30 }, (_, i) => [`field${i}`, `value ${i}`]));
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Applying a large patch",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "tall-tool-call",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes }
-				} })
-			}]
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		await click("[data-test-pretui-tool-row-toggle]");
-		await waitFor("[data-test-pretui-code]");
-		await settled();
-		let codeBlockSelector = "[data-test-tool-call-id=\"tall-tool-call\"] [data-test-pretui-code]";
-		assert.dom(codeBlockSelector).exists("tool code block element exists");
-		let codeBlock = find(codeBlockSelector);
-		assert.strictEqual(codeBlock.style.height, "", "no inline height is stamped when the code is expanded");
-		let childrenHeight = [...codeBlock.children].reduce((sum, child) => sum + child.offsetHeight, 0);
-		assert.ok(codeBlock.offsetHeight <= childrenHeight + 4, `expanded code block height (${codeBlock.offsetHeight}px) should not exceed its rendered children (${childrenHeight}px)`);
-	});
-	(0, import_qunit.test)("when command in a message with continuations is done streaming, apply button is shown in ready state", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		let initialEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: false
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_HAS_CONTINUATION_CONTENT_KEY]: true,
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: initialEventId
-			}
-		});
-		let continuationEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first names",
-			format: "org.matrix.custom.html",
-			[APP_BOXEL_CONTINUATION_OF_CONTENT_KEY]: initialEventId,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
-				name: "patchCard"
-			}],
-			isStreamingFinished: false
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		assert.dom("[data-test-message-idx]").exists({ count: 1 });
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists();
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first names",
-			format: "org.matrix.custom.html",
-			[APP_BOXEL_CONTINUATION_OF_CONTENT_KEY]: initialEventId,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
-				name: "patchCard",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}, {
-				id: "f2da5504-b92f-480a-986a-56ec606d240e",
-				name: "patchCard",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/hassan`,
-					patch: { attributes: { firstName: "Ivana" } }
-				} })
-			}],
-			isStreamingFinished: false,
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: continuationEventId
-			}
-		});
-		await settled();
-		assert.dom("[data-test-message-idx]").exists({ count: 1 });
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists({ count: 2 }, "each call still arriving is a streaming row");
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first names",
-			format: "org.matrix.custom.html",
-			[APP_BOXEL_CONTINUATION_OF_CONTENT_KEY]: initialEventId,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
-				name: "patchCard",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}, {
-				id: "f2da5504-b92f-480a-986a-56ec606d240e",
-				name: "patchCard",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/hassan`,
-					patch: { attributes: { firstName: "Ivana" } }
-				} })
-			}],
-			isStreamingFinished: true,
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: continuationEventId
-			}
-		});
-		await settled();
-		assert.dom("[data-test-message-idx]").exists({ count: 1 });
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").doesNotExist("every call has arrived");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"ready\"]").exists({ count: 2 });
-	});
-	(0, import_qunit.skip)("command that returns a FileForAttachmentCard result is specially handled to attach the file", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]", { timeout: 1e4 });
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Reading hello file",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "0ce51dc1-c819-4d6d-9f4f-77fbf60e9a0a",
-				name: "read-file-for-ai-assistant_a831",
-				arguments: JSON.stringify({ attributes: { fileIdentifier: `${testRealmURL}hello.txt` } })
-			}]
-		});
-		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
-		assert.strictEqual(commandResultEvents.length, 0, "command result event is not dispatched");
-		await settled();
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
-		await waitFor("[data-test-tool-call-card-idle]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists();
-		commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
-		assert.strictEqual(commandResultEvents.length, 1, "command result event is dispatched");
-		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedFiles.length, 1, "command result event contains an attached file");
-		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedFiles[0].name, "hello.txt", "command result event contains attached file");
-		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedFiles[0].sourceUrl, "http://test-realm/test/hello.txt", "command result event contains file whose url was reference in the input of the command as an attached file");
-	});
-	(0, import_qunit.skip)("command that returns a CardForAttachmentCard result is specially handled to attach the card", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]", { timeout: 1e4 });
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Reading card",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "1ef9a66a-2201-4874-a156-9705acb1ac13",
-				name: "read-card-for-ai-assistant_dd38",
-				arguments: JSON.stringify({ attributes: { cardId: `${testRealmURL}Pet/mango` } })
-			}]
-		});
-		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
-		assert.strictEqual(commandResultEvents.length, 0, "command result event is not dispatched");
-		await settled();
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
-		await waitFor("[data-test-tool-call-card-idle]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists();
-		commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
-		assert.strictEqual(commandResultEvents.length, 1, "command result event is dispatched");
-		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedCards.length, 1, "command result event contains an attached file");
-		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedCards[0].name, "Mango", "command result event contains attached card");
-		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedCards[0].sourceUrl, "http://test-realm/test/Pet/mango", "command result event contains file whose url was reference in the input of the command as an attached file");
-	});
-	(0, import_qunit.test)("commandResult event_id is sourced from current room state, not a streaming snapshot", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		let commandRequestId = "cmd-request-id";
-		let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: false
-		});
-		let replacedEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first name to Evie",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: commandRequestId,
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}],
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: streamingEventId
-			}
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
-		await waitFor("[data-test-tool-call-card-idle]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists("MessageTool status should flip to applied even though commandResult.m.relates_to.event_id is the m.replace id, not the streaming id the cache is keyed by");
-		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation");
-		assert.strictEqual(commandResultEvents.length, 1, "exactly one commandResult should be dispatched");
-		assert.strictEqual(commandResultEvents[0].content["m.relates_to"]?.event_id, replacedEventId, "commandResult.m.relates_to.event_id should be the bot message event_id currently in room.events that owns the toolRequest, not a stale snapshot of the streaming/original id");
-		assert.notStrictEqual(commandResultEvents[0].content["m.relates_to"]?.event_id, streamingEventId, "commandResult should not reference the original/streaming event_id once a later event in room.events owns the toolRequest");
-	});
-	(0, import_qunit.test)("an applied command on a streamed bot message still renders applied after reload (m.replace edits stripped)", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		let commandRequestId = "cmd-request-id";
-		let strippedEditEventId = "stripped-edit-event-id";
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first name to Evie",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: commandRequestId,
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}]
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-			commandRequestId,
-			"m.relates_to": {
-				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-				key: "applied",
-				event_id: strippedEditEventId
-			},
-			data: {}
-		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		await waitFor("[data-test-message-idx=\"0\"]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists("a command applied before reload still renders applied even though its commandResult links to a stripped m.replace edit id; correlation is by commandRequestId, not the dangling event_id");
-	});
-	(0, import_qunit.test)("an applied commandResult flips only its own bot message, not a sibling message that also carries a command", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "test room 1"
-		});
-		let firstCommandRequestId = "first-cmd-request-id";
-		let secondCommandRequestId = "second-cmd-request-id";
-		let strippedEditEventId = "stripped-edit-event-id";
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first name to Evie",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: firstCommandRequestId,
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Evie" } }
-				} })
-			}]
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changing first name to Mango",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: secondCommandRequestId,
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Mango" } }
-				} })
-			}]
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-			commandRequestId: secondCommandRequestId,
-			"m.relates_to": {
-				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-				key: "applied",
-				event_id: strippedEditEventId
-			},
-			data: {}
-		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"test room 1\"]");
-		await waitFor("[data-test-message-idx=\"1\"]");
-		assert.dom("[data-test-message-idx=\"1\"] [data-test-tool-call-apply=\"applied\"]").exists("the bot message whose commandRequestId owns the applied result renders applied");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"ready\"]").exists("the sibling bot message, which has no result of its own, stays ready — the applied status did not bleed across messages");
-	});
-	(0, import_qunit.test)("Accept All bar does not flash for an always-auto-executed command (checkCorrectness)", async function(assert) {
-		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
-			body: "checking correctness",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "cs-11647-check-correctness",
-				name: "checkCorrectness",
-				arguments: "{}"
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitFor("[data-test-message-idx=\"0\"]");
-		assert.dom("[data-test-accept-all]").doesNotExist("Accept All button must not paint in the debounce window before auto-execute starts");
-		await settled();
-		assert.dom("[data-test-accept-all]").doesNotExist("Accept All button still hidden after the auto-execute debounce window elapses");
-	});
-	(0, import_qunit.test)("Accept All bar does not flash for a requiresApproval=false command", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hk0qKyFP",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "auto-exec via skill"
-		});
-		await settled();
-		await click("[data-test-open-ai-assistant]");
-		await waitFor("[data-test-room-name=\"auto-exec via skill\"]", { timeout: 1e4 });
-		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
-		simulateRemoteMessage(document.querySelector("[data-test-room]").getAttribute("data-test-room"), "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Reading hello file",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "cs-11647-no-approval",
-				name: "read-file-for-ai-assistant_a831",
-				arguments: JSON.stringify({ attributes: { fileIdentifier: `${testRealmURL}hello.txt` } })
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitFor("[data-test-message-idx=\"0\"]");
-		assert.dom("[data-test-accept-all]").doesNotExist("Accept All button suppressed for requiresApproval=false commands");
-	});
-	(0, import_qunit.test)("per-command Apply button does not flash Run before auto-execute starts", async function(assert) {
-		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
-			body: "checking correctness",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "cs-11647-apply-button",
-				name: "checkCorrectness",
-				arguments: "{}"
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"ready\"]").doesNotExist("per-command Apply button must not show the ready/Run state for an auto-executed command");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applying\"]").exists("per-command Apply button shows the applying spinner instead");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-card-idle]").doesNotExist("data-test-tool-call-card-idle agrees with applyButtonState while the synthetic spinner is on");
-	});
-	(0, import_qunit.test)("stuck-processing helper dispatches an invalid commandResult for each auto-executable command", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let matrixService = getService("matrix-service");
-		let toolService = getService("tool-service");
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			body: "checking correctness",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "cs-11647-stuck-auto",
-				name: "checkCorrectness",
-				arguments: "{}"
-			}, {
-				id: "cs-11647-stuck-manual",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Dave" } }
-				} })
-			}],
-			data: { context: { agentId: matrixService.agentId } }
-		});
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		let roomResource = matrixService.roomResources.get(roomId);
-		let message = roomResource.messages.find((m) => m.tools?.length === 2);
-		assert.ok(message, "two-command bot message lands in the room resource");
-		let captured = [];
-		let originalSend = matrixService.sendToolResultEvent.bind(matrixService);
-		matrixService.sendToolResultEvent = async (params) => {
-			captured.push({
-				toolCallId: params.toolCallId,
-				failureReason: params.failureReason
-			});
-		};
-		try {
-			await toolService.invalidateAutoExecutableToolsForStuckProcessing(roomResource, roomId, message.eventId);
-		} finally {
-			matrixService.sendToolResultEvent = originalSend;
-		}
-		assert.strictEqual(captured.length, 1, "only the auto-executable command is invalidated; manual-approval command is left in ready");
-		assert.strictEqual(captured[0]?.toolCallId, "cs-11647-stuck-auto", "the dispatched invalid event targets the auto-executable command");
-		assert.true((captured[0]?.failureReason ?? "").startsWith("Room processing did not finish within"), "failureReason surfaces the stuck-processing cause for the invalidToolCallState alert");
-	});
-	(0, import_qunit.test)("an invalid result is terminal for auto-execution: a later drain pass does not re-resolve the request", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let matrixService = getService("matrix-service");
-		let toolService = getService("tool-service");
-		let captured = [];
-		let originalSend = matrixService.sendToolResultEvent.bind(matrixService);
-		matrixService.sendToolResultEvent = async (params) => {
-			captured.push({
-				toolCallId: params.toolCallId,
-				status: params.status
-			});
-		};
-		try {
-			let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-				body: "Do the thing",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-					id: "cs-12103-invalid-terminal",
-					name: "no-such-command",
-					arguments: JSON.stringify({
-						description: "do it",
-						attributes: {}
-					})
-				}],
-				data: { context: { agentId: matrixService.agentId } }
-			});
-			await settled();
-			assert.deepEqual(captured, [{
-				toolCallId: "cs-12103-invalid-terminal",
-				status: "invalid"
-			}], "validation resolves the request invalid exactly once");
-			assert.true(toolService.claimedToolRequestIds.has("cs-12103-invalid-terminal"), "the terminal resolution is recorded locally, not just in the (still in-flight) result event");
-			toolService.queueEventForToolProcessing({
-				event_id: eventId,
-				room_id: roomId,
-				content: {}
-			});
-			await settled();
-			assert.strictEqual(captured.length, 1, "the resolved request gets no second result and is not executed");
-		} finally {
-			matrixService.sendToolResultEvent = originalSend;
-		}
-	});
-	(0, import_qunit.test)("overlapping drain passes resolve a tool request exactly once", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let matrixService = getService("matrix-service");
-		let toolService = getService("tool-service");
-		let captured = [];
-		let originalSend = matrixService.sendToolResultEvent.bind(matrixService);
-		matrixService.sendToolResultEvent = async (params) => {
-			captured.push({
-				toolCallId: params.toolCallId,
-				status: params.status
-			});
-		};
-		let overlapAgentId = "overlap-test-agent";
-		let originalAgentId = matrixService.agentId;
-		try {
-			let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-				body: "Do the thing",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-					id: "overlap-victim",
-					name: "checkCorrectness",
-					arguments: "not parseable json, so validation resolves invalid"
-				}],
-				data: { context: { agentId: overlapAgentId } }
-			});
-			await settled();
-			assert.strictEqual(captured.length, 0, "the not-our-agent message is left unresolved by the timeline drain");
-			matrixService.agentId = overlapAgentId;
-			let svc = toolService;
-			svc.toolProcessingEventQueue.push(`${roomId}|${eventId}`);
-			let firstPass = svc.drainToolProcessingQueue();
-			await Promise.resolve();
-			svc.flushToolProcessingQueue = void 0;
-			svc.toolProcessingEventQueue.push(`${roomId}|${eventId}`);
-			let secondPass = svc.drainToolProcessingQueue();
-			await Promise.all([firstPass, secondPass]);
-			await settled();
-			assert.deepEqual(captured, [{
-				toolCallId: "overlap-victim",
-				status: "invalid"
-			}], "the request gets exactly one terminal result across both passes");
-		} finally {
-			matrixService.agentId = originalAgentId;
-			matrixService.sendToolResultEvent = originalSend;
-		}
-	});
-	const discoveredSkillUrl = `${testRealmURL}Skill/boxel-environment`;
-	const discoveredHostToolName = buildToolFunctionNameFromResolvedRef({
-		module: "@cardstack/boxel-host/commands/read-file-for-ai-assistant",
-		name: "default"
-	});
-	function simulateDiscoveredToolResult(roomId) {
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE,
-			commandRequestId: "earlier-skill-read",
-			"m.relates_to": {
-				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-				key: "applied",
-				event_id: "earlier-bot-message"
-			},
-			data: {
-				attachedFiles: [],
-				discoveredTools: [{
-					sourceSkillUrl: discoveredSkillUrl,
-					codeRef: {
-						module: "@cardstack/boxel-host/commands/read-file-for-ai-assistant",
-						name: "default"
-					},
-					functionName: discoveredHostToolName,
-					requiresApproval: false,
-					definition: {
-						type: "function",
-						function: {
-							name: discoveredHostToolName,
-							description: "Read a file",
-							parameters: {
-								type: "object",
-								properties: {}
-							}
-						}
-					}
-				}]
-			}
-		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-	}
-	async function seedDiscoveredHostToolTurn(roomId) {
-		let agentId = getService("matrix-service").agentId;
-		simulateDiscoveredToolResult(roomId);
-		let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Reading",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: false,
-			data: { context: { agentId } }
-		});
-		await settled();
-		return streamingEventId;
-	}
-	function holdDiscoveredSkillLoads() {
-		let store = getService("store");
-		let toolService = getService("tool-service");
-		let originalValidateTimeoutMs = toolService.validateTimeoutMs;
-		toolService.validateTimeoutMs = 6e4;
-		let release = new Deferred();
-		let heldLoads = 0;
-		let originalGet = store.get;
-		store.get = async (id, ...rest) => {
-			if (id === discoveredSkillUrl) {
-				heldLoads++;
-				await release.promise;
-			}
-			return originalGet.call(store, id, ...rest);
-		};
-		return {
-			get heldLoads() {
-				return heldLoads;
-			},
-			async reached() {
-				await waitUntil(() => heldLoads > 0, {
-					timeout: 5e3,
-					timeoutMessage: "the final edit never started resolving the discovered host tool (no load of its skill within 5s)"
-				});
-			},
-			release() {
-				release.fulfill();
-				store.get = originalGet;
-				toolService.validateTimeoutMs = originalValidateTimeoutMs;
-			}
-		};
-	}
-	function failDiscoveredSkillLoads() {
-		let store = getService("store");
-		let originalGet = store.get;
-		store.get = async (id, ...rest) => {
-			if (id === discoveredSkillUrl) throw new Error("simulated skill load failure");
-			return originalGet.call(store, id, ...rest);
-		};
-		return { restore() {
-			store.get = originalGet;
-		} };
-	}
-	function failCommandModuleImport() {
-		let loaderPrototype = Object.getPrototypeOf(getService("loader-service").loader);
-		let originalImport = loaderPrototype.import;
-		let importsRefused = 0;
-		loaderPrototype.import = async function(moduleId, ...rest) {
-			if (String(moduleId).includes("read-file-for-ai-assistant")) {
-				importsRefused++;
-				throw new Error("simulated command module load failure");
-			}
-			return originalImport.call(this, moduleId, ...rest);
-		};
-		return {
-			get importsRefused() {
-				return importsRefused;
-			},
-			restore() {
-				loaderPrototype.import = originalImport;
-			}
-		};
-	}
-	function finalEditWithHostTool(streamingEventId, body, toolRequests) {
-		return {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [...toolRequests, {
-				id: "slow-host-read",
-				name: discoveredHostToolName,
-				arguments: JSON.stringify({ attributes: { fileIdentifier: `${testRealmURL}hello.txt` } })
-			}],
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: streamingEventId
-			},
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		};
-	}
-	async function drainIsValidating(toolCallId) {
-		let toolService = getService("tool-service");
-		await waitUntil(() => toolService.validationSteps.has(toolCallId), {
-			timeout: 5e3,
-			timeoutMessage: `the tool drain never started validating ${toolCallId}`
-		});
-	}
-	(0, import_qunit.test)("a host tool whose resolution outlasts a room-processing restart still runs", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
-		let hold = holdDiscoveredSkillLoads();
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", [{
-				id: "bot-run-read",
-				name: "readRealmFile",
-				arguments: JSON.stringify({ path: "hello.txt" }),
-				executedBy: AI_BOT_EXECUTOR
-			}]));
-			await hold.reached();
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-				commandRequestId: "bot-run-read",
-				"m.relates_to": {
-					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-					key: "applied",
-					event_id: streamingEventId
-				}
-			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-			await drainIsValidating("slow-host-read");
-			assert.strictEqual(hold.heldLoads, 1, "neither the restarted room pass nor the drain starts a second resolution");
-		} finally {
-			hold.release();
-		}
-		await settled();
-		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
-		assert.strictEqual(hostToolResults.length, 1, "the host tool resolved after the restart is run and its result posted");
-		assert.strictEqual(hostToolResults[0]?.content["m.relates_to"]?.key, "applied", `the host tool ran successfully (failure reason: ${hostToolResults[0]?.content.failureReason ?? "none"})`);
-		assert.dom("[data-test-tool-call-apply=\"applying\"]").doesNotExist("no tool is left spinning in the applying state");
-	});
-	(0, import_qunit.test)("a response-stream preview that arrives while the final edit resolves its tools does not overwrite it", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
-		let matrixService = getService("matrix-service");
-		let hold = holdDiscoveredSkillLoads();
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "The final answer.", []));
-			await hold.reached();
-			simulateToDeviceEvent(APP_BOXEL_RESPONSE_STREAM_EVENT_TYPE, {
-				roomId,
-				parentEventId: streamingEventId,
-				sequence: 99,
-				body: "A stale preview.",
-				reasoning: "",
-				toolRequests: []
-			}, matrixService.aiBotUserId);
-			await delay(100);
-		} finally {
-			hold.release();
-		}
-		await settled();
-		let message = matrixService.roomResources.get(roomId).messageForEventId(streamingEventId);
-		assert.strictEqual(message.body, "The final answer.", "the final edit keeps its body");
-		assert.true(message.isStreamingFinished, "the message stays finished");
-		assert.dom(`[data-test-room="${roomId}"]`).doesNotContainText("A stale preview.");
-	});
-	(0, import_qunit.test)("a host tool whose command never resolves gets a terminal invalid result and the room keeps processing", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
-		let fail = failDiscoveredSkillLoads();
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
-			await settled();
-		} finally {
-			fail.restore();
-		}
-		await settled();
-		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
-		assert.strictEqual(hostToolResults.length, 1, "exactly one terminal result is posted for the request that never resolved");
-		assert.strictEqual(hostToolResults[0]?.content["m.relates_to"]?.key, "invalid", "the unresolvable tool is reported invalid");
-		assert.dom("[data-test-tool-call-apply=\"applying\"]").doesNotExist("no tool is left spinning in the applying state");
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Still alive",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await settled();
-		assert.dom(`[data-test-room="${roomId}"]`).containsText("Still alive", "the room keeps processing later events");
-	});
-	(0, import_qunit.test)("a host tool renamed by the final edit runs as the renamed tool, not the stale one", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Reading",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: false,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "slow-host-read",
-				name: "read-file-for"
-			}],
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: streamingEventId
-			},
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await settled();
-		let hold = holdDiscoveredSkillLoads();
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
-			await hold.reached();
-			await drainIsValidating("slow-host-read");
-			assert.strictEqual(getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read").length, 0, "the drain waits for the renamed tool instead of validating the stale name");
-		} finally {
-			hold.release();
-		}
-		await settled();
-		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
-		assert.strictEqual(hostToolResults.length, 1, "exactly one result");
-		assert.strictEqual(hostToolResults[0]?.content["m.relates_to"]?.key, "applied", `the renamed tool ran (failure reason: ${hostToolResults[0]?.content.failureReason ?? "none"})`);
-	});
-	(0, import_qunit.test)("a call that already has a result is not answered again when its command no longer resolves", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
-		let fail = failDiscoveredSkillLoads();
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
-			simulateRemoteMessage(roomId, "@testuser:localhost", {
-				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-				commandRequestId: "slow-host-read",
-				"m.relates_to": {
-					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-					key: "applied",
-					event_id: streamingEventId
-				}
-			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-			await settled();
-		} finally {
-			fail.restore();
-		}
-		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
-		assert.deepEqual(hostToolResults.map((event) => event.content["m.relates_to"]?.key), ["applied"], "only the existing result, no contradictory invalid");
-	});
-	(0, import_qunit.test)("a call whose command fails to load gets a terminal invalid result saying it could not be prepared", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
-		let toolService = getService("tool-service");
-		let originalValidateTimeoutMs = toolService.validateTimeoutMs;
-		toolService.validateTimeoutMs = 6e4;
-		let fail = failCommandModuleImport();
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
-			await settled();
-		} finally {
-			fail.restore();
-			toolService.validateTimeoutMs = originalValidateTimeoutMs;
-		}
-		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
-		assert.strictEqual(hostToolResults.length, 1, "exactly one result");
-		assert.strictEqual(hostToolResults[0]?.content["m.relates_to"]?.key, "invalid", "the call is reported invalid");
-		assert.true(String(hostToolResults[0]?.content.failureReason).includes("could not be prepared (simulated command module load failure)"), `the reason names the load failure: ${hostToolResults[0]?.content.failureReason}`);
-		assert.dom("[data-test-tool-call-apply=\"applying\"]").doesNotExist("no tool is left spinning in the applying state");
-	});
-	(0, import_qunit.test)("a validation that times out and then finds the call invalid leaves only the failed result", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
-		let toolService = getService("tool-service");
-		let originalValidateTimeoutMs = toolService.validateTimeoutMs;
-		let hold = holdDiscoveredSkillLoads();
-		toolService.validateTimeoutMs = 200;
-		let fail = failCommandModuleImport();
-		let toolResults = () => getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
-			await hold.reached();
-			await waitUntil(() => toolResults().length > 0, {
-				timeout: 5e3,
-				timeoutMessage: "the drain never reported the validation timeout"
-			});
-		} finally {
-			hold.release();
-		}
-		try {
-			await waitUntil(() => toolService.validationsInFlight === 0, {
-				timeout: 1e4,
-				timeoutMessage: "the timed-out validation never finished"
-			});
-			await settled();
-		} finally {
-			fail.restore();
-			toolService.validateTimeoutMs = originalValidateTimeoutMs;
-		}
-		assert.true(fail.importsRefused > 0, "the timed-out validation went on to the command module import");
-		assert.deepEqual(toolResults().map((event) => event.content["m.relates_to"]?.key), ["failed"], "only the timeout result, no contradictory invalid");
-	});
-	(0, import_qunit.test)("a call whose invalid result cannot be sent still gets a failed result", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
-		let toolService = getService("tool-service");
-		let originalValidateTimeoutMs = toolService.validateTimeoutMs;
-		toolService.validateTimeoutMs = 6e4;
-		let matrixService = getService("matrix-service");
-		let originalSend = matrixService.sendToolResultEvent;
-		let refusedSends = 0;
-		matrixService.sendToolResultEvent = async function(params, ...rest) {
-			if (params.status === "invalid") {
-				refusedSends++;
-				throw new Error("simulated invalid result send failure");
-			}
-			return originalSend.call(matrixService, params, ...rest);
-		};
-		let fail = failCommandModuleImport();
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
-			await settled();
-		} finally {
-			fail.restore();
-			matrixService.sendToolResultEvent = originalSend;
-			toolService.validateTimeoutMs = originalValidateTimeoutMs;
-		}
-		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
-		assert.strictEqual(refusedSends, 1, "the invalid result was refused");
-		assert.deepEqual(hostToolResults.map((event) => event.content["m.relates_to"]?.key), ["failed"], "the call still gets a terminal result");
-		let failureReason = String(hostToolResults[0]?.content.failureReason);
-		assert.true(failureReason.includes("could not be prepared (simulated command module load failure)"), `the reason still says why the call was invalid: ${failureReason}`);
-		assert.true(failureReason.includes("simulated invalid result send failure"), `the reason names the send failure: ${failureReason}`);
-	});
-	(0, import_qunit.test)("another agent's call that first resolved to no command is resolved again when its request finishes", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let otherAgentContext = { context: { agentId: "another-agent" } };
-		let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Reading",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: false,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "other-agent-read",
-				name: discoveredHostToolName
-			}],
-			data: otherAgentContext
-		});
-		await settled();
-		let roomResource = getService("matrix-service").roomResources.get(roomId);
-		let tool = () => roomResource.messageForEventId(streamingEventId).tools.find((t) => t.id === "other-agent-read");
-		assert.strictEqual(tool().codeRef, void 0, "no command is found yet");
-		simulateDiscoveredToolResult(roomId);
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Reading",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "other-agent-read",
-				name: discoveredHostToolName,
-				arguments: JSON.stringify({ attributes: { fileIdentifier: `${testRealmURL}hello.txt` } })
-			}],
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: streamingEventId
-			},
-			data: otherAgentContext
-		});
-		await settled();
-		assert.strictEqual(tool().codeRef?.module, "@cardstack/boxel-host/commands/read-file-for-ai-assistant", "the finished call resolves to its command in a tab whose drain doesn't run it");
-		assert.strictEqual(tool().actionVerb, "Send", "the command's action verb");
-		assert.strictEqual(getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "other-agent-read").length, 0, "this tab does not run another agent's call");
-	});
-	(0, import_qunit.test)("Accept All bar still renders for a command that requires user approval", async function(assert) {
-		simulateRemoteMessage(await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`), "@aibot:localhost", {
-			body: "patching",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "cs-11647-patch",
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Dave" } }
-				} })
-			}]
-		});
-		await waitFor("[data-test-accept-all]");
-		assert.dom("[data-test-accept-all]").exists("manual approval bar still renders for commands that need user approval");
-		assert.dom("[data-test-stop-generating]").doesNotExist("nothing runs until the user approves, so there is no Stop");
-	});
-	function stubToolValidation({ held = false, heldToolIds, rejectSend } = {}) {
-		let toolService = getService("tool-service");
-		let matrixService = getService("matrix-service");
-		let release;
-		let released = held || heldToolIds ? new Promise((resolve) => release = resolve) : Promise.resolve();
-		let validating = /* @__PURE__ */ new Set();
-		let originalValidate = toolService.validate;
-		toolService.validate = async (messageTool) => {
-			if (messageTool.id) validating.add(messageTool.id);
-			if (!heldToolIds || heldToolIds.includes(messageTool.id ?? "")) await released;
-			return { valid: true };
-		};
-		let results = [];
-		let originalSend = matrixService.sendToolResultEvent;
-		matrixService.sendToolResultEvent = async function(params) {
-			results.push({
-				toolCallId: params.toolCallId,
-				status: params.status,
-				failureReason: params.failureReason,
-				resumesAssistant: params.resumesAssistant
-			});
-			if (rejectSend?.(params)) throw new Error("the result could not be sent");
-			return originalSend.call(this, params);
-		};
-		return {
-			results,
-			validating,
-			release: () => release?.(),
-			restore() {
-				release?.();
-				toolService.validate = originalValidate;
-				matrixService.sendToolResultEvent = originalSend;
-			}
-		};
-	}
-	function checkCorrectnessCall(toolCallId) {
-		return {
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: toolCallId,
-				name: "checkCorrectness",
-				arguments: "{}"
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		};
-	}
-	async function stopWhileStreaming(roomId, toolCallId, stop, toolRequests = checkCorrectnessCall(toolCallId)) {
-		let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Checking",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: false,
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		});
-		await waitFor("[data-test-stop-generating]");
-		await stop();
-		await waitUntil(() => !document.querySelector("[data-test-stop-generating]"), { timeout: 5e3 });
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Checking correctness",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			...toolRequests,
-			"m.relates_to": {
-				rel_type: "m.replace",
-				event_id: streamingEventId
-			}
-		});
-		return streamingEventId;
-	}
-	function patchPersonCall(toolCallId) {
-		return {
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: toolCallId,
-				name: "patchCardInstance",
-				arguments: JSON.stringify({ attributes: {
-					cardId: `${testRealmURL}Person/fadhlan`,
-					patch: { attributes: { firstName: "Dave" } }
-				} })
-			}],
-			data: { context: { agentId: getService("matrix-service").agentId } }
-		};
-	}
-	(0, import_qunit.test)("Stop is offered while a tool of the answer runs", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation({ held: true });
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				body: "checking correctness",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				...checkCorrectnessCall("running-tool")
-			});
-			await waitFor("[data-test-stop-generating]");
-			assert.dom("[data-test-ai-assistant-action-bar]").containsText("Running tools", "the bar says tools are running");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a tool the user stopped before it started never runs", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation();
-		try {
-			await stopWhileStreaming(roomId, "stopped-before-run", () => click("[data-test-stop-generating]"));
-			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
-			await settled();
-			assert.strictEqual(JSON.stringify(stub.results), JSON.stringify([{
-				toolCallId: "stopped-before-run",
-				status: "canceled",
-				failureReason: STOPPED_TOOL_CALL_REASON
-			}]), "the tool is answered as canceled instead of run");
-			assert.dom("[data-test-tool-call-apply=\"canceled\"]").exists("the tool reads as canceled");
-			assert.dom("[data-test-stop-generating]").doesNotExist("Stop is not offered again for the stopped loop");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a stop sent from the user's other client keeps a tool here from starting", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation();
-		try {
-			await stopWhileStreaming(roomId, "stopped-elsewhere", async () => {
-				simulateRemoteMessage(roomId, "@testuser:localhost", {}, { type: APP_BOXEL_STOP_GENERATING_EVENT_TYPE });
-			});
-			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
-			await settled();
-			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
-				toolCallId,
-				status
-			}))), JSON.stringify([{
-				toolCallId: "stopped-elsewhere",
-				status: "canceled"
-			}]));
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a stop whose timestamp reads earlier than the answer still stops that answer", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation();
-		try {
-			await stopWhileStreaming(roomId, "stopped-with-skewed-clock", async () => {
-				simulateRemoteMessage(roomId, "@testuser:localhost", {}, {
-					type: APP_BOXEL_STOP_GENERATING_EVENT_TYPE,
-					origin_server_ts: 1
-				});
-			});
-			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
-			await settled();
-			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
-				toolCallId,
-				status
-			}))), JSON.stringify([{
-				toolCallId: "stopped-with-skewed-clock",
-				status: "canceled"
-			}]));
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a stop the server has not confirmed yet holds although its clock reads earlier than the prompt", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation();
-		let releaseSend;
-		let held = false;
-		mockMatrixUtils.setSendEventInterceptor(async () => {
-			if (held) return;
-			held = true;
-			await new Promise((resolve) => releaseSend = resolve);
-		});
-		try {
-			let serverAhead = Date.now() + 3600 * 1e3;
-			simulateRemoteMessage(roomId, "@testuser:localhost", {
-				body: "check it",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html"
-			}, { origin_server_ts: serverAhead });
-			let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				body: "Checking",
-				format: "org.matrix.custom.html",
-				isStreamingFinished: false,
-				data: { context: { agentId: getService("matrix-service").agentId } }
-			}, { origin_server_ts: serverAhead + 1 });
-			await waitFor("[data-test-stop-generating]");
-			let matrixService = getService("matrix-service");
-			matrixService.sendStopGeneratingEvent(roomId);
-			let roomResource = matrixService.roomResources.get(roomId);
-			await waitUntil(() => roomResource.events.some((event) => event.type === "app.boxel.stopGenerating" && event.status === "sending"));
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				body: "Checking correctness",
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				...checkCorrectnessCall("stopped-while-sending"),
-				"m.relates_to": {
-					rel_type: "m.replace",
-					event_id: streamingEventId
-				}
-			}, { origin_server_ts: serverAhead + 2 });
-			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
-			await settled();
-			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
-				toolCallId,
-				status
-			}))), JSON.stringify([{
-				toolCallId: "stopped-while-sending",
-				status: "canceled"
-			}]));
-		} finally {
-			mockMatrixUtils.setSendEventInterceptor(void 0);
-			releaseSend?.();
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a stop during a later tool's validation keeps the tools validated before it from starting", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation({ heldToolIds: ["validated-last"] });
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				body: "checking correctness twice",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-					id: "validated-first",
-					name: "checkCorrectness",
-					arguments: "{}"
-				}, {
-					id: "validated-last",
-					name: "checkCorrectness",
-					arguments: "{}"
-				}],
-				data: { context: { agentId: getService("matrix-service").agentId } }
-			});
-			await waitUntil(() => stub.validating.has("validated-last"), { timeout: 1e4 });
-			simulateRemoteMessage(roomId, "@testuser:localhost", {}, { type: APP_BOXEL_STOP_GENERATING_EVENT_TYPE });
-			let roomResource = getService("matrix-service").roomResources.get(roomId);
-			await waitUntil(() => roomResource.stopState.inForce !== void 0);
-			stub.release();
-			await waitUntil(() => stub.results.length === 2, { timeout: 1e4 });
-			await settled();
-			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
-				toolCallId,
-				status
-			}))), JSON.stringify([{
-				toolCallId: "validated-first",
-				status: "canceled"
-			}, {
-				toolCallId: "validated-last",
-				status: "canceled"
-			}]), "neither tool had started when the user stopped, so neither runs");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("Stop is not offered for a tool another of the user's clients runs", async function(assert) {
-		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
-			body: "checking correctness",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "other-client-tool",
-				name: "checkCorrectness",
-				arguments: "{}"
-			}],
-			data: { context: { agentId: "another-client-agent" } }
-		});
-		let offered = "[data-test-accept-all], [data-test-tool-call-id=\"other-client-tool\"] [data-test-pretui-tool-gate-action=\"apply\"]";
-		await waitFor(offered);
-		assert.dom("[data-test-stop-generating]").doesNotExist("only the client that runs the tool offers Stop for it");
-		assert.dom(offered).exists("this client offers the call like any other");
-	});
-	(0, import_qunit.test)("a message from the user after a stop lets the next tools run", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation();
-		try {
-			await stopWhileStreaming(roomId, "stopped-first", () => click("[data-test-stop-generating]"));
-			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
-			simulateRemoteMessage(roomId, "@testuser:localhost", {
-				body: "try again",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html"
-			});
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				body: "checking correctness again",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				...checkCorrectnessCall("after-new-message")
-			});
-			await waitUntil(() => stub.results.some((r) => r.toolCallId === "after-new-message"), { timeout: 2e4 });
-			await settled();
-			assert.notStrictEqual(stub.results.find((r) => r.toolCallId === "after-new-message")?.status, "canceled", "the stop no longer applies after the user writes again");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("running a tool of the stopped answer by hand resumes the assistant", async function(assert) {
-		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`);
-		let stub = stubToolValidation();
-		try {
-			await stopWhileStreaming(roomId, "run-after-stop", () => click("[data-test-stop-generating]"), patchPersonCall("run-after-stop"));
-			await waitFor("[data-test-tool-call-apply=\"ready\"]");
-			let roomResource = getService("matrix-service").roomResources.get(roomId);
-			assert.ok(roomResource.stopState.inForce, "the stop is in force");
-			await click("[data-test-pretui-tool-gate-action=\"apply\"]");
-			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
-			await settled();
-			assert.strictEqual(JSON.stringify(stub.results), JSON.stringify([{
-				toolCallId: "run-after-stop",
-				status: "applied",
-				resumesAssistant: true
-			}]), "the result says the user asked for the call to go ahead");
-			assert.notOk(roomResource.stopState.inForce, "the result lifts the stop");
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				body: "Applied, now",
-				format: "org.matrix.custom.html",
-				isStreamingFinished: false,
-				data: { context: { agentId: getService("matrix-service").agentId } }
-			});
-			await waitFor("[data-test-stop-generating]");
-			assert.dom("[data-test-stop-generating]").exists("Stop is offered again for the answer that follows");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("every answer sends a result; the last call waiting on a message also gets a reaction", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation();
-		let matrixService = getService("matrix-service");
-		let originalReact = matrixService.sendReactionEvent;
-		let reactions = [];
-		matrixService.sendReactionEvent = async (_roomId, eventId, key) => {
-			reactions.push({
-				eventId,
-				key
-			});
-			return { event_id: "$reaction" };
-		};
-		try {
-			let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-				body: "may I read these?",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				[APP_BOXEL_TOOL_REQUESTS_KEY]: ["approved-read", "declined-read"].map((id) => ({
-					id,
-					name: "readUrl",
-					arguments: JSON.stringify({ url: `https://example.com/${id}` }),
-					executedBy: AI_BOT_EXECUTOR,
-					approvalRequired: true
-				}))
-			});
-			let roomResource = getService("matrix-service").roomResources.get(roomId);
-			await waitUntil(() => roomResource.messages[0]?.tools.length === 2, { timeout: 1e4 });
-			let [approved, declined] = roomResource.messages[0].tools;
-			let toolService = getService("tool-service");
-			await toolService.answerApproval.unlinked().perform(approved, "approve");
-			await toolService.answerApproval.unlinked().perform(declined, "decline");
-			await settled();
-			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status, resumesAssistant }) => ({
-				toolCallId,
-				status,
-				resumesAssistant
-			}))), JSON.stringify([{
-				toolCallId: "approved-read",
-				status: "approved",
-				resumesAssistant: true
-			}, {
-				toolCallId: "declined-read",
-				status: "invalid"
-			}]), "each answer is a result ai-bot acts on");
-			assert.deepEqual(reactions, [{
-				eventId,
-				key: "👎"
-			}], "only the last call waiting on the message adds a 👎, since a reaction answers the whole message");
-		} finally {
-			matrixService.sendReactionEvent = originalReact;
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a reaction after each call has its result changes neither answer", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			body: "may I read these?",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: ["approved-read", "declined-read"].map((id) => ({
-				id,
-				name: "readUrl",
-				arguments: JSON.stringify({ url: `https://example.com/${id}` }),
-				executedBy: AI_BOT_EXECUTOR,
-				approvalRequired: true
-			}))
-		});
-		let roomResource = getService("matrix-service").roomResources.get(roomId);
-		await waitUntil(() => roomResource.messages[0]?.tools.length === 2, { timeout: 1e4 });
-		for (let [commandRequestId, key] of [["approved-read", "approved"], ["declined-read", "invalid"]]) simulateRemoteMessage(roomId, "@testuser:localhost", {
-			msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-			commandRequestId,
-			"m.relates_to": {
-				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-				key,
-				event_id: eventId
-			},
-			data: {}
-		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-		simulateRemoteMessage(roomId, "@testuser:localhost", { "m.relates_to": {
-			rel_type: "m.annotation",
-			event_id: eventId,
-			key: "👎"
-		} }, { type: "m.reaction" });
-		await settled();
-		let [approved, declined] = roomResource.messages[0].tools;
-		assert.strictEqual(approved.toolCallStatus, "approved");
-		assert.strictEqual(approved.approvalAnswer, void 0, "the 👎 that follows the last answer does not decline the approved call");
-		assert.strictEqual(declined.toolCallStatus, "invalid");
-	});
-	(0, import_qunit.test)("a 👍 from a room member approves the held call and says who", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation();
-		try {
-			let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-				body: "may I read this?",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-					id: "held-read",
-					name: "readUrl",
-					arguments: JSON.stringify({ url: "https://example.com/a" }),
-					executedBy: AI_BOT_EXECUTOR,
-					approvalRequired: true
-				}]
-			});
-			await waitFor("[data-test-tool-call-id=\"held-read\"] [data-test-tool-call-approval]");
-			simulateRemoteMessage(roomId, "@rupert:localhost", { "m.relates_to": {
-				rel_type: "m.annotation",
-				event_id: eventId,
-				key: "👍"
-			} }, { type: "m.reaction" });
-			await waitFor("[data-test-tool-call-approval-answer=\"approve\"]");
-			assert.dom("[data-test-tool-call-approval-answer=\"approve\"]").includesText("👍");
-			assert.dom("[data-test-tool-call-id=\"held-read\"] [data-test-tool-call-approval]").doesNotExist("the call no longer asks");
-			assert.strictEqual(stub.results.length, 0, "the host sends no result of its own");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a canceled result that cannot be sent shows the tool as failed, not spinning", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation({ rejectSend: ({ status }) => status === "canceled" });
-		try {
-			await stopWhileStreaming(roomId, "canceled-send-fails", () => click("[data-test-stop-generating]"));
-			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
-			await settled();
-			assert.strictEqual(stub.results[0]?.status, "canceled");
-			assert.dom("[data-test-tool-call-apply=\"failed\"]").exists("the tool offers Retry instead of a spinner");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a tool already running when the user stops keeps its spinner until its result lands", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let toolService = getService("tool-service");
-		toolService.currentlyExecutingToolRequestIds.add("already-running");
-		try {
-			let eventId = await stopWhileStreaming(roomId, "already-running", () => click("[data-test-stop-generating]"));
-			await waitFor("[data-test-tool-call-apply=\"applying\"]");
-			assert.dom("[data-test-tool-call-apply=\"canceled\"]").doesNotExist("a running tool is not shown as canceled");
-			await settled();
-			toolService.currentlyExecutingToolRequestIds.delete("already-running");
-			simulateRemoteMessage(roomId, "@testuser:localhost", {
-				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-				commandRequestId: "already-running",
-				"m.relates_to": {
-					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-					key: "applied",
-					event_id: eventId
-				}
-			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-			await waitFor("[data-test-tool-call-apply=\"applied\"]", { timeout: 1e4 });
-			assert.dom("[data-test-tool-call-apply=\"applied\"]").exists("its result still lands");
-		} finally {
-			toolService.currentlyExecutingToolRequestIds.delete("already-running");
-		}
-	});
-	(0, import_qunit.test)("Stop is not offered for an answer that ended in an error", async function(assert) {
-		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
-			body: "reading",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			errorMessage: "The model stopped answering",
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: "read-that-never-ran",
-				name: "readUrl",
-				arguments: JSON.stringify({ url: "https://example.com" }),
-				executedBy: AI_BOT_EXECUTOR
-			}]
-		});
-		await waitFor("[data-test-message-idx=\"0\"]");
-		await settled();
-		assert.dom("[data-test-stop-generating]").doesNotExist("the bot never reached its call, so nothing is running");
-	});
-	(0, import_qunit.test)("Stop is not offered for a tool whose result could not be sent", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation({ held: true });
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				body: "checking correctness",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				...checkCorrectnessCall("result-never-sent")
-			});
-			await waitFor("[data-test-stop-generating]");
-			getService("matrix-service").failedToolState.set("result-never-sent", /* @__PURE__ */ new Error("the result could not be sent"));
-			await settled();
-			assert.dom("[data-test-stop-generating]").doesNotExist("no result will ever come, so nothing is running");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a stopped answer's tool stays stopped after the user writes again", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation({ held: true });
-		try {
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				body: "checking correctness",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				...checkCorrectnessCall("stopped-then-written")
-			});
-			await waitUntil(() => stub.validating.has("stopped-then-written"), { timeout: 1e4 });
-			simulateRemoteMessage(roomId, "@testuser:localhost", {}, { type: APP_BOXEL_STOP_GENERATING_EVENT_TYPE });
-			simulateRemoteMessage(roomId, "@testuser:localhost", {
-				body: "never mind",
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				format: "org.matrix.custom.html"
-			});
-			let roomResource = getService("matrix-service").roomResources.get(roomId);
-			await waitUntil(() => roomResource.messages.length === 2);
-			assert.notOk(roomResource.stopState.inForce, "the stop is lifted");
-			stub.release();
-			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
-			await settled();
-			assert.strictEqual(stub.results[0]?.status, "canceled", "the tool the user stopped never runs, lifted stop or not");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("running one tool of a stopped answer by hand does not start its others", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let stub = stubToolValidation({ heldToolIds: ["left-over"] });
-		try {
-			let eventId = await stopWhileStreaming(roomId, "left-over", () => click("[data-test-stop-generating]"), {
-				[APP_BOXEL_TOOL_REQUESTS_KEY]: [...patchPersonCall("run-by-hand")[APP_BOXEL_TOOL_REQUESTS_KEY], {
-					id: "left-over",
-					name: "checkCorrectness",
-					arguments: "{}"
-				}],
-				data: { context: { agentId: getService("matrix-service").agentId } }
-			});
-			await waitUntil(() => stub.validating.has("left-over"), { timeout: 1e4 });
-			simulateRemoteMessage(roomId, "@testuser:localhost", {
-				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-				commandRequestId: "run-by-hand",
-				resumesAssistant: true,
-				"m.relates_to": {
-					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-					key: "applied",
-					event_id: eventId
-				}
-			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-			let roomResource = getService("matrix-service").roomResources.get(roomId);
-			await waitUntil(() => !roomResource.stopState.inForce);
-			stub.release();
-			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
-			await settled();
-			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
-				toolCallId,
-				status
-			}))), JSON.stringify([{
-				toolCallId: "left-over",
-				status: "canceled"
-			}]), "the user asked for one call, not the rest");
-		} finally {
-			stub.restore();
-		}
-	});
-	(0, import_qunit.test)("a call's latest result and the room's last activity follow the timeline, not the order events arrived in", async function(assert) {
-		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`);
-		let now = Date.now();
-		let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
-			body: "patching",
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			...patchPersonCall("retried-patch")
-		}, { origin_server_ts: now });
-		let result = (key, origin_server_ts) => simulateRemoteMessage(roomId, "@testuser:localhost", {
-			msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-			commandRequestId: "retried-patch",
-			"m.relates_to": {
-				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-				key,
-				event_id: eventId
-			}
-		}, {
-			type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE,
-			origin_server_ts
-		});
-		result("applied", now + 2e3);
-		await waitFor("[data-test-tool-call-apply=\"applied\"]");
-		result("failed", now + 1e3);
-		await settled();
-		assert.dom("[data-test-tool-call-apply=\"applied\"]").exists("the later result is the outcome, whenever it arrived");
-		let roomResource = getService("matrix-service").roomResources.get(roomId);
-		assert.strictEqual(roomResource.lastActiveTimestamp, now + 2e3, "the room was last active at its newest event");
-	});
-	function simulateShowCardResult(roomId, snapshotFirstName, cardId = `${testRealmURL}Person/fadhlan`) {
-		let snapshotUrl = "mxc://mock-server/fadhlan-snapshot";
-		let matrixService = getService("matrix-service");
-		let originalDownload = matrixService.downloadCardFileDef.bind(matrixService);
-		matrixService.downloadCardFileDef = async (serializedFile) => {
-			if (serializedFile.url !== snapshotUrl) return originalDownload(serializedFile);
-			return { data: {
-				id: cardId,
-				type: "card",
-				attributes: { firstName: snapshotFirstName },
-				meta: { adoptsFrom: {
-					module: `${testRealmURL}person`,
-					name: "Person"
-				} }
-			} };
-		};
-		let commandRequestId = "show-card-request-id";
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Showing the card",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-				id: commandRequestId,
-				name: "showCard",
-				arguments: JSON.stringify({ attributes: { cardId } })
-			}]
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE,
-			commandRequestId,
-			"m.relates_to": {
-				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-				key: "applied",
-				event_id: "bot-message-event-id"
-			},
-			data: { card: {
-				url: snapshotUrl,
-				sourceUrl: cardId,
-				name: "Fadhlan",
-				contentType: "application/vnd.card+json"
-			} }
-		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-	}
-	(0, import_qunit.test)("rendering a tool result that snapshots a card already in the store leaves the live instance untouched", async function(assert) {
-		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`);
-		await waitFor("[data-test-person=\"Fadhlan\"]");
-		let savedFirstNames = [];
-		this.onSave((_, json) => {
-			if (typeof json === "string") throw new Error("expected JSON save data");
-			savedFirstNames.push(json.data.attributes?.firstName);
-		});
-		simulateShowCardResult(roomId, "Stale");
-		await waitForToolResult("[data-test-boxel-tool-call-result]");
-		await settled();
-		assert.dom("[data-test-person]").hasText("Fadhlan", "the card in the stack still shows the live data");
-		let live = getService("store").peek(`${testRealmURL}Person/fadhlan`);
-		assert.strictEqual(live?.firstName, "Fadhlan", "the resident instance keeps its live fields");
-		assert.dom("[data-test-boxel-tool-call-result]").containsText("Fadhlan", "the tool result renders the live card");
-		assert.deepEqual(savedFirstNames, [], "rendering the tool result does not save anything");
-		live.firstName = "Fadhlan Updated";
-		await settled();
-		assert.dom("[data-test-boxel-tool-call-result]").containsText("Fadhlan Updated", "the tool result follows the resident instance");
-		assert.deepEqual(savedFirstNames, ["Fadhlan Updated"], "the autosave writes the live value");
-	});
-	(0, import_qunit.test)("rendering a tool result that snapshots a card not yet in the store loads the live card instead of the snapshot", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		this.onSave(() => {
-			assert.ok(false, "rendering a tool result must not trigger a save");
-		});
-		simulateShowCardResult(roomId, "Stale");
-		await waitForToolResult("[data-test-boxel-tool-call-result]");
-		await settled();
-		let live = getService("store").peek(`${testRealmURL}Person/fadhlan`);
-		assert.strictEqual(live?.firstName, "Fadhlan", "the store holds the live card, not the room snapshot");
-		assert.dom("[data-test-boxel-tool-call-result]").containsText("Fadhlan", "the tool result renders the live card");
-	});
-	(0, import_qunit.test)("rendering a tool result whose live card no longer exists renders the snapshot without installing it under the card id", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		this.onSave(() => {
-			assert.ok(false, "rendering a tool result must not trigger a save");
-		});
-		let deletedId = `${testRealmURL}Person/deleted`;
-		simulateShowCardResult(roomId, "Snapshot", deletedId);
-		await waitForToolResult("[data-test-boxel-tool-call-result]");
-		await settled();
-		assert.dom("[data-test-boxel-tool-call-result]").containsText("Snapshot", "the tool result falls back to rendering the snapshot");
-		let store = getService("store");
-		assert.false(isCardInstance(store.peek(deletedId)), "the snapshot is not installed in the store under the realm id");
-	});
-	(0, import_qunit.test)("opening a fold of messages that each ran the same tool shows every call", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let renameTo = (name) => {
-			let requestId = `rename-${name}`;
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				body: "",
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-					id: requestId,
-					name: "patchCardInstance",
-					arguments: JSON.stringify({
-						description: `Rename to ${name}`,
-						attributes: {
-							cardId: `${testRealmURL}Person/fadhlan`,
-							patch: { attributes: { firstName: name } }
-						}
-					})
-				}]
-			});
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-				commandRequestId: requestId,
-				"m.relates_to": {
-					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-					key: "applied",
-					event_id: requestId
-				},
-				data: {}
-			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-		};
-		for (let name of [
-			"Ada",
-			"Bea",
-			"Cy",
-			"Dee"
-		]) renameTo(name);
-		await waitFor("[data-test-message-idx=\"3\"] [data-test-tool-run-group=\"4\"]");
-		for (let index of [
-			0,
-			1,
-			2
-		]) assert.dom(`[data-test-message-idx="${index}"]`).doesNotExist(`the earlier message ${index} folds into the latest`);
-		assert.dom("[data-test-message-idx=\"3\"] [data-test-pretui-tool-group-header]").containsText("×4", "the latest message reads as the whole run");
-		await click("[data-test-message-idx=\"3\"] [data-test-pretui-tool-group-header]");
-		assert.dom("[data-test-message-idx=\"3\"] [data-test-tool-run-group] [data-test-tool-call-apply=\"applied\"]").exists({ count: 4 }, "opening the fold shows every call of the run");
-		for (let name of [
-			"Ada",
-			"Bea",
-			"Cy",
-			"Dee"
-		]) assert.dom("[data-test-message-idx=\"3\"] [data-test-tool-run-group]").containsText(`to ${name}`, `the call renaming to ${name} shows`);
-		renameTo("Eve");
-		await waitFor("[data-test-message-idx=\"4\"] [data-test-tool-run-group=\"5\"]");
-		assert.dom("[data-test-message-idx=\"4\"] [data-test-tool-run-group] [data-test-tool-call-apply=\"applied\"]").exists({ count: 5 }, "the fold stays open as the run grows");
-		await click("[data-test-message-idx=\"4\"] [data-test-pretui-tool-group-header]");
-		renameTo("Fay");
-		await waitFor("[data-test-message-idx=\"5\"] [data-test-tool-run-group=\"6\"]");
-		assert.dom("[data-test-message-idx=\"5\"] [data-test-pretui-tool-group-header]").hasAttribute("aria-expanded", "false", "the fold stays closed as the run grows");
-	});
-	(0, import_qunit.test)("a run of two messages that each ran the same tool folds into one group", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		for (let name of ["Ada", "Bea"]) {
-			let requestId = `rename-${name}`;
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-				body: "",
-				format: "org.matrix.custom.html",
-				isStreamingFinished: true,
-				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
-					id: requestId,
-					name: "patchCardInstance",
-					arguments: JSON.stringify({
-						description: `Rename to ${name}`,
-						attributes: {
-							cardId: `${testRealmURL}Person/fadhlan`,
-							patch: { attributes: { firstName: name } }
-						}
-					})
-				}]
-			});
-			simulateRemoteMessage(roomId, "@aibot:localhost", {
-				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
-				commandRequestId: requestId,
-				"m.relates_to": {
-					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-					key: "applied",
-					event_id: requestId
-				},
-				data: {}
-			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-		}
-		await waitFor("[data-test-message-idx=\"1\"] [data-test-tool-run-group=\"2\"]");
-		assert.dom("[data-test-message-idx=\"0\"]").doesNotExist("the earlier message folds into the latest");
-		assert.dom("[data-test-message-idx=\"1\"] [data-test-pretui-tool-group-header]").containsText("×2", "the latest message reads as both calls");
-		await click("[data-test-message-idx=\"1\"] [data-test-pretui-tool-group-header]");
-		assert.dom("[data-test-message-idx=\"1\"] [data-test-tool-run-group] [data-test-tool-call-apply=\"applied\"]").exists({ count: 2 }, "opening the fold shows both calls");
-	});
-	function simulateToolResult(roomId, { requestId, toolName, resultDoc, args = {}, inMedia = false }) {
-		let resultUrl = `mxc://mock-server/${requestId}-result`;
-		let matrixService = getService("matrix-service");
-		let originalDownload = matrixService.downloadCardFileDef.bind(matrixService);
-		matrixService.downloadCardFileDef = async (serializedFile) => {
-			if (serializedFile.url !== resultUrl) return originalDownload(serializedFile);
-			return resultDoc;
-		};
-		let toolRequests = [{
-			id: requestId,
-			name: toolName,
-			arguments: JSON.stringify(args)
-		}];
-		let requestsField = { [APP_BOXEL_TOOL_REQUESTS_KEY]: toolRequests };
-		if (inMedia) {
-			let requestsUrl = `mxc://mock-server/${requestId}-requests`;
-			let mediaId = requestsUrl.slice(18);
-			let originalFetch = matrixService.fetchMatrixHostedFile.bind(matrixService);
-			matrixService.fetchMatrixHostedFile = async (url) => url.endsWith(`/${mediaId}`) ? new Response(JSON.stringify(toolRequests)) : originalFetch(url);
-			requestsField = { [APP_BOXEL_EXTERNAL_FIELDS_KEY]: { [APP_BOXEL_TOOL_REQUESTS_KEY]: requestsUrl } };
-		}
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: `Running ${toolName}`,
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true,
-			...requestsField
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE,
-			commandRequestId: requestId,
-			"m.relates_to": {
-				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
-				key: "applied",
-				event_id: "bot-message-event-id"
-			},
-			data: { card: {
-				url: resultUrl,
-				sourceUrl: resultUrl,
-				name: `${toolName} result`,
-				contentType: "application/vnd.card+json"
-			} }
-		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
-	}
-	function baseCommandResultDoc(name, attributes) {
-		return { data: {
-			type: "card",
-			attributes,
-			meta: { adoptsFrom: {
-				module: rri("@cardstack/base/command"),
-				name
-			} }
-		} };
-	}
-	(0, import_qunit.test)("a result card whose type has no view of its own stays out of the chat", async function(assert) {
-		simulateToolResult(await renderAiAssistantPanel(), {
-			requestId: "data-only-result",
-			toolName: "oneShotLLMRequest",
-			resultDoc: baseCommandResultDoc("OneShotLLMRequestResult", { output: "a reply for the model" })
-		});
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
-		await settled();
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists("the tool row shows the call as applied");
-		assert.dom("[data-test-tool-result-container]").doesNotExist("the data-only result card is not rendered");
-	});
-	(0, import_qunit.test)("a result card whose type has its own embedded view is shown", async function(assert) {
-		simulateToolResult(await renderAiAssistantPanel(), {
-			requestId: "patch-fields-result",
-			toolName: "patchFields",
-			resultDoc: baseCommandResultDoc("PatchFieldsOutput", {
-				success: true,
-				updatedFields: ["firstName"],
-				errors: {}
-			})
-		});
-		await waitForToolResult();
-		assert.dom("[data-test-tool-result-header]").containsText("patchFields", "the result's meta line names the call");
-		assert.dom("[data-test-boxel-tool-call-result]").containsText("Updated 1 field: firstName.");
-	});
-	(0, import_qunit.test)("a failed correctness check shows its failed state without a result card", async function(assert) {
-		simulateToolResult(await renderAiAssistantPanel(), {
-			requestId: "failed-correctness-check",
-			toolName: "checkCorrectness",
-			resultDoc: baseCommandResultDoc("CorrectnessResultCard", {
-				correct: false,
-				errors: ["The card does not render"],
-				warnings: []
-			})
-		});
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied-with-error\"]");
-		assert.dom("[data-test-message-idx=\"0\"] .room-message-tool.is-failed").exists("the tool row shows the failed check");
-		assert.dom("[data-test-tool-result-container]").doesNotExist("the correctness result card is not rendered");
-	});
-	(0, import_qunit.test)("a check of several targets lists its errors and counts the rest", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let target = (n) => `${testRealmURL}Product/${n}`;
-		simulateToolResult(roomId, {
-			requestId: "batched-correctness-check",
-			toolName: "checkCorrectness",
-			args: {
-				description: "Check 3 cards and 1 file",
-				attributes: { targets: [
-					{
-						type: "file",
-						ref: `${testRealmURL}product.gts`
-					},
-					{
-						type: "card",
-						ref: target(1)
-					},
-					{
-						type: "card",
-						ref: target(2)
-					},
-					{
-						type: "card",
-						ref: target(3)
-					}
-				] }
-			},
-			resultDoc: baseCommandResultDoc("CorrectnessResultCard", {
-				correct: false,
-				errors: [`${target(2)}: price must be a number`],
-				warnings: [],
-				targetResults: [{
-					targetType: "card",
-					targetRef: target(2),
-					errors: [`${target(2)}: price must be a number`],
-					warnings: []
-				}],
-				checkedCount: 4,
-				passedCount: 3
-			})
-		});
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied-with-error\"]");
-		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row-toggle]");
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-check-outcome]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row-title]").hasText("Checked 3 cards and 1 file · errors", "the row counts what it checked");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-check-outcome]").containsText(`${target(2)}: price must be a number`, "the error is listed").containsText("No errors in the other 2 cards and 1 file", "the passing targets are counted");
-	});
-	(0, import_qunit.test)("a check request carried in Matrix media is shown like an inline one", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let target = (n) => `${testRealmURL}Product/${n}`;
-		simulateToolResult(roomId, {
-			requestId: "media-correctness-check",
-			toolName: "checkCorrectness",
-			inMedia: true,
-			args: {
-				description: "Check 2 cards",
-				attributes: { targets: [{
-					type: "card",
-					ref: target(1)
-				}, {
-					type: "card",
-					ref: target(2)
-				}] }
-			},
-			resultDoc: baseCommandResultDoc("CorrectnessResultCard", {
-				correct: true,
-				errors: [],
-				warnings: [],
-				targetResults: [],
-				checkedCount: 2,
-				passedCount: 2
-			})
-		});
-		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row-title]");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row-title]").containsText("Checked 2 cards", "the request was read from media");
-	});
-	(0, import_qunit.test)("a view-visually result shows the image the assistant looked at", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let imageUrl = new URL("/_matrix/client/v1/media/download/localhost/brand-guide-capture", config.matrixURL).href;
-		let pngBytes = Uint8Array.from(atob("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="), (c) => c.charCodeAt(0));
-		mockMatrixUtils.getUploadedContents().set(imageUrl, pngBytes.buffer);
-		simulateToolResult(roomId, {
-			requestId: "view-visually-result",
-			toolName: "view-visually",
-			resultDoc: baseCommandResultDoc("ViewVisuallyResult", {
-				sourceUrl: `${testRealmURL}brand-guide.html`,
-				kind: "file",
-				format: "isolated",
-				attachedImages: [{
-					name: "brand-guide.html (isolated).png",
-					url: imageUrl,
-					contentType: "image/png"
-				}]
-			})
-		});
-		await waitFor("[data-test-view-visually-image][src^=\"blob:\"]");
-		assert.dom("[data-test-view-visually-title]").hasText("View of brand-guide.html");
-		assert.dom("[data-test-boxel-tool-call-result]").containsText(`${testRealmURL}brand-guide.html`);
-		let image = find("[data-test-view-visually-image]");
-		await image.decode();
-		assert.strictEqual(image.naturalWidth, 1, "the image loads from the room media downloaded with the session");
-	});
-	(0, import_qunit.test)("room media is loaded with the Matrix session only from the homeserver", async function(assert) {
-		let matrixService = getService("matrix-service");
-		let elsewhere = "https://elsewhere.example/_matrix/client/v1/media/download/x/y";
-		assert.strictEqual(await matrixService.loadRoomMedia(elsewhere), elsewhere, "a URL on another origin comes back unchanged, without a download");
-		let realmFile = `${testRealmURL}brand-guide.png`;
-		assert.strictEqual(await matrixService.loadRoomMedia(realmFile), realmFile, "a URL that is not room media comes back unchanged");
-		let homeserverApi = new URL("/_matrix/client/v3/sync", config.matrixURL).href;
-		assert.strictEqual(await matrixService.loadRoomMedia(homeserverApi), homeserverApi, "a homeserver URL outside its media downloads comes back unchanged");
-	});
-	(0, import_qunit.test)("a run-realm-code result lists the files it saved and the captures it took", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let captureUrl = new URL("/_matrix/client/v1/media/download/localhost/run-capture", config.matrixURL).href;
-		let pngBytes = Uint8Array.from(atob("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="), (c) => c.charCodeAt(0));
-		mockMatrixUtils.getUploadedContents().set(captureUrl, pngBytes.buffer);
-		let savedFile = `${testRealmURL}brand-guide.html`;
-		simulateToolResult(roomId, {
-			requestId: "run-realm-code-result",
-			toolName: "run-realm-code",
-			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
-				files: [{
-					fileUrl: savedFile,
-					status: "saved"
-				}],
-				scriptResult: "done",
-				captures: [{
-					name: "brand-guide.html (isolated).png",
-					url: captureUrl,
-					contentType: "image/png"
-				}]
-			})
-		});
-		await waitFor("[data-test-realm-code-capture][src^=\"blob:\"]");
-		assert.dom(`[data-test-realm-code-file="${savedFile}"]`).exists("the saved file is listed; its check says it was saved");
-		assert.dom("[data-test-boxel-tool-call-result]").doesNotContainText("done", "the script's own result stays out of the chat");
-	});
-	(0, import_qunit.test)("a file in a turn's changed files opens in code mode", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let changedFile = `${testRealmURL}hello-world.gts`;
-		simulateRemoteMessage(roomId, "@testuser:localhost", {
-			body: "Change the greeting",
-			msgtype: "m.text"
-		});
-		simulateToolResult(roomId, {
-			requestId: "run-realm-code-edit",
-			toolName: "run-realm-code",
-			resultDoc: baseCommandResultDoc("RunRealmCodeResult", { files: [{
-				fileUrl: changedFile,
-				status: "saved",
-				diff: "-  greeting = 'Hello';\n+  greeting = 'Hi';"
-			}] })
-		});
-		simulateRemoteMessage(roomId, "@aibot:localhost", {
-			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
-			body: "Changed the greeting.",
-			format: "org.matrix.custom.html",
-			isStreamingFinished: true
-		});
-		await waitFor("[data-test-pretui-turn-changes-file$=\"hello-world.gts\"]");
-		assert.strictEqual(operatorModeStateService.state.submode, Submodes.Interact, "the app starts in interact mode");
-		await click("[data-test-pretui-turn-changes-file$=\"hello-world.gts\"]");
-		await waitUntil(() => operatorModeStateService.state.submode === Submodes.Code);
-		assert.strictEqual(operatorModeStateService.state.codePath, rri(changedFile), "code mode opens on the changed file, not on the previous one");
-	});
-	(0, import_qunit.test)("a run-realm-code result says why it could not show a card", async function(assert) {
-		simulateToolResult(await renderAiAssistantPanel(), {
-			requestId: "run-realm-code-not-shown",
-			toolName: "run-realm-code",
-			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
-				files: [],
-				scriptResult: JSON.stringify({ show: "images/red.png" }),
-				captures: [],
-				showError: "The card was not shown. images/red.png is a file"
-			})
-		});
-		await waitFor("[data-test-realm-code-show-error]");
-		assert.dom("[data-test-realm-code-show-error]").containsText("The card was not shown", "the reason is shown");
-	});
-	(0, import_qunit.test)("a run-realm-code result lists its UI moves, a failed one with why", async function(assert) {
-		simulateToolResult(await renderAiAssistantPanel(), {
-			requestId: "run-realm-code-ui-actions",
-			toolName: "run-realm-code",
-			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
-				files: [],
-				scriptResult: "",
-				captures: [],
-				uiActions: [{
-					action: "openFile",
-					target: `${testRealmURL}pet.gts`,
-					status: "done"
-				}, {
-					action: "previewFormat",
-					target: `${testRealmURL}Pet/mango (fitted)`,
-					status: "failed",
-					detail: "Card not found"
-				}]
-			})
-		});
-		await waitFor("[data-test-realm-code-ui-action=\"previewFormat\"]");
-		assert.dom("[data-test-realm-code-ui-action=\"openFile\"]").exists("a done UI move is said too, so the reader sees what moved");
-		assert.dom("[data-test-realm-code-ui-action=\"previewFormat\"]").containsText("Card not found", "a failed action says why");
-	});
-	(0, import_qunit.test)("a run-realm-code result lists the workspaces it created and deleted", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let created = "http://test-realm/new-workspace/";
-		let deleted = "http://test-realm/old-workspace/";
-		simulateToolResult(roomId, {
-			requestId: "run-realm-code-workspaces",
-			toolName: "run-realm-code",
-			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
-				files: [],
-				scriptResult: "",
-				captures: [],
-				createdWorkspaces: [created],
-				deletedWorkspaces: [deleted]
-			})
-		});
-		await waitFor("[data-test-realm-code-created-workspace]");
-		assert.dom("[data-test-realm-code-created-workspace]").containsText(created, "the created workspace is listed");
-		assert.dom("[data-test-realm-code-deleted-workspace]").containsText(deleted, "the deleted workspace is listed");
-	});
-	(0, import_qunit.test)("a run-realm-code result that wrote nothing and had no failure stays out of the chat", async function(assert) {
-		let roomId = await renderAiAssistantPanel();
-		let store = getService("store");
-		let addWithoutPersisting = store.addWithoutPersisting.bind(store);
-		let resultCardMade = new Promise((resolve) => {
-			store.addWithoutPersisting = async (...args) => {
-				let card = await addWithoutPersisting(...args);
-				resolve();
-				return card;
-			};
-		});
-		simulateToolResult(roomId, {
-			requestId: "run-realm-code-read-only",
-			toolName: "run-realm-code",
-			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
-				files: [],
-				scriptResult: JSON.stringify({ show: "Pet/mango" }),
-				captures: [{
-					name: "pet.gts (isolated).png",
-					url: new URL("/_matrix/client/v1/media/download/localhost/read-only-capture", config.matrixURL).href,
-					contentType: "image/png"
-				}],
-				shownCard: `${testRealmURL}Pet/mango`,
-				uiActions: [{
-					action: "switchSubmode",
-					target: "code",
-					status: "done"
-				}, {
-					action: "openFile",
-					target: `${testRealmURL}pet.gts`,
-					status: "done"
-				}]
-			})
-		});
-		await resultCardMade;
-		await settled();
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists("the tool row shows the call as applied");
-		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-card-embed]").doesNotExist("a run that only read, captured, and opened things has no result card");
-	});
-});
-//#endregion