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

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

@@ -0,0 +1,1624 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { $n as APP_BOXEL_TOOL_REQUESTS_KEY, Ar as testRealmURL, Bn as APP_BOXEL_LLM_MODE, Dr as testRRI, Fr as Tool, Lr as buildCommandFunctionName, Rr as buildCommandFunctionNameFromResolvedRef, Sc as Deferred, Vn as APP_BOXEL_MESSAGE_MSGTYPE, er as APP_BOXEL_TOOL_RESULT_EVENT_TYPE, nr as APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE, rr as APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE, tr as APP_BOXEL_TOOL_RESULT_REL_TYPE } from "./runtime-common-ClpqhbwG.js";
+import { D as baseRealm, J as skillCardRef, V as localId } from "./constants-CqKWhRfY.js";
+import { r as setOwner } from "./owner-CP0__uFm.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory, S as on } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./modifier-D0EP-FQ7.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { O as GridContainer } from "./components-Ct_agx0G.js";
+import { r as CreateAiAssistantRoomTool } from "./ai-assistant-o-VoxzZ0.js";
+import { M as waitUntil, T as settled, d as click, i as findAll, k as visit, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as OpenAiAssistantRoomTool } from "./open-ai-assistant-room-N1HReeGq.js";
+import { a as waitForRealmState, i as waitForCompletedCommandRequest, t as SendAiAssistantMessageTool } from "./send-ai-assistant-message-DlhNmLE3.js";
+import { t as ShowCardTool } from "./show-card-Dwfk332M.js";
+import { t as SaveCardTool } from "./save-card-DkGJIGeF.js";
+import { n as SearchCardsByTypeAndTitleTool } from "./search-cards-C2h2J40C.js";
+import { t as ViewVisuallyTool } from "./view-visually-D0BZ5yxV.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, F as setupLocalIndexing, H as testModuleRealm, I as setupOnSave, Y as waitForNewRoomSkillsLoaded, _t as registerRealmServerRoute, a as SYSTEM_CARD_FIXTURE_CONTENTS, bt as unregisterRealmServerRoute, ct as setupApplicationTest, j as setupAcceptanceTestRealm, o as addSkillToAiAssistant, pt as setupAuthEndpoints, st as visitOperatorMode, t as setupMockMatrix, z as setupUserSubscription } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, C as card_api_exports, H as linksTo, U as linksToMany, a as CardDef, s as Component, w as contains } from "./card-api-Dzje0smT.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+import { t as CardsGrid } from "./cards-grid-CWG41hZE.js";
+import { t as suspendGlobalErrorHook } from "./uncaught-exceptions-Cm9iqRb6.js";
+//#region tests/acceptance/tools-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var matrixRoomId = "";
+var maybeBoomShouldBoom = true;
+var linkEchoMessages = [];
+var linkEchoProbe;
+var savedMeetingCardId;
+(0, import_qunit.module)("Acceptance | Tools tests", function(hooks) {
+	const showCardToolName = buildCommandFunctionNameFromResolvedRef({
+		module: "@cardstack/boxel-host/commands/show-card",
+		name: "default"
+	});
+	const viewVisuallyToolName = buildCommandFunctionNameFromResolvedRef({
+		module: "@cardstack/boxel-host/tools/view-visually",
+		name: "default"
+	});
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, testRealmURL]
+	});
+	let { simulateRemoteMessage, getRoomIds, getRoomEvents, getRoomState, createAndJoinRoom } = mockMatrixUtils;
+	function toolResultFor(roomId, toolCallId) {
+		return getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === toolCallId).pop();
+	}
+	function describeToolResult(roomId, toolCallId) {
+		let content = toolResultFor(roomId, toolCallId)?.content;
+		return content ? `result is ${content["m.relates_to"]?.key} (${content.failureReason ?? "no failure reason"})` : "no result event";
+	}
+	hooks.beforeEach(async function() {
+		savedMeetingCardId = void 0;
+		linkEchoMessages = [];
+		linkEchoProbe = void 0;
+		matrixRoomId = await createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room-test"
+		});
+		setupUserSubscription();
+		setupAuthEndpoints();
+		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, "favoriteTreat", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#favoriteTreat = (initializeDeferredDecorator(this, "favoriteTreat"), 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 embedded = class Embedded extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "mGs5q2q4",
+						"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/acceptance/tools-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "N4AVF92C",
+						"block": "[[[8,[32,0],[[24,0,\"container\"]],null,[[\"default\"],[[[[1,\"\\n  \"],[10,\"h2\"],[12],[8,[30,1,[\"cardTitle\"]],null,null,null],[13],[1,\"\\n  \"],[10,0],[12],[1,\"\\n    \"],[10,0],[12],[1,\"Favorite Treat: \"],[8,[30,1,[\"favoriteTreat\"]],null,null,null],[13],[1,\"\\n    \"],[10,0],[14,\"data-test-editable-meta\",\"\"],[12],[1,\"\\n\"],[41,[30,2],[[[1,\"        \"],[8,[30,1,[\"cardTitle\"]],null,null,null],[1,\"\\n        is editable.\\n\"]],[]],[[[1,\"        \"],[8,[30,1,[\"cardTitle\"]],null,null,null],[1,\"\\n        is NOT editable.\\n\"]],[]]],[1,\"    \"],[13],[1,\"\\n  \"],[13],[1,\"\\n\"]],[]]]]]],[\"@fields\",\"@canEdit\"],[\"if\"]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/tools-test.gts",
+						"scope": () => [GridContainer],
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class ScheduleMeetingInput extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "topic", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#topic = (initializeDeferredDecorator(this, "topic"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "participants", [field], function() {
+					return linksToMany(() => Person);
+				});
+			}
+			#participants = (initializeDeferredDecorator(this, "participants"), void 0);
+		}
+		class Meeting extends CardDef {
+			static displayName = "Meeting";
+			static {
+				decorateFieldV2(this.prototype, "participants", [field], function() {
+					return linksToMany(() => Person);
+				});
+			}
+			#participants = (initializeDeferredDecorator(this, "participants"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "topic", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#topic = (initializeDeferredDecorator(this, "topic"), void 0);
+		}
+		class ScheduleMeetingCommand extends Tool {
+			static displayName = "ScheduleMeetingCommand";
+			static actionVerb = "Schedule";
+			async getInputType() {
+				return ScheduleMeetingInput;
+			}
+			async run(input) {
+				let meeting = new Meeting({
+					topic: "unset topic",
+					participants: input.participants
+				});
+				savedMeetingCardId = (await new SaveCardTool(this.toolContext).execute({
+					card: meeting,
+					realm: testRealmURL
+				}))?.id;
+				let { roomId } = await new CreateAiAssistantRoomTool(this.toolContext).execute({ name: "AI Assistant Room" });
+				let { eventId } = await new SendAiAssistantMessageTool(this.toolContext).execute({
+					roomId,
+					prompt: `Change the topic of the meeting to "${input.topic}"`,
+					attachedCards: [meeting]
+				});
+				await waitForCompletedCommandRequest(this.toolContext, roomId, (toolRequest) => toolRequest.name === "patchCardInstance", { afterEventId: eventId });
+				await waitForRealmState(this.toolContext, testRealmURL, () => meeting.topic === input.topic);
+				await new ShowCardTool(this.toolContext).execute({ cardId: meeting.id });
+			}
+		}
+		class RealmViewerCommand extends ViewVisuallyTool {
+			async run() {
+				let { ViewVisuallyResult, AttachedImageField } = await this.loadToolModule();
+				return new ViewVisuallyResult({
+					sourceUrl: `${testRealmURL}Pet/mango`,
+					kind: "card",
+					format: "isolated",
+					attachedImages: [new AttachedImageField({
+						name: "mango.png",
+						sourceUrl: "boxel-local://capture/mango.png",
+						url: "mxc://localhost/mango",
+						contentType: "image/png",
+						contentSize: 68
+					})]
+				});
+			}
+		}
+		class MaybeBoomCommand extends Tool {
+			static displayName = "MaybeBoomCommand";
+			static actionVerb = "Boom?";
+			async getInputType() {}
+			async run() {
+				if (maybeBoomShouldBoom) throw new Error("Boom!");
+			}
+		}
+		class SearchAndOpenCardCommand extends Tool {
+			static displayName = "SearchAndOpenCardCommand";
+			static actionVerb = "Search";
+			async getInputType() {
+				return new SearchCardsByTypeAndTitleTool(this.toolContext).getInputType();
+			}
+			async run(input) {
+				let searchResult = await new SearchCardsByTypeAndTitleTool(this.toolContext).execute(input);
+				if (searchResult.cardIds.length > 0) await new ShowCardTool(this.toolContext).execute({ cardId: searchResult.cardIds[0] });
+			}
+		}
+		class GreetingCard extends CardDef {
+			static displayName = "GreetingCard";
+			static {
+				decorateFieldV2(this.prototype, "message", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#message = (initializeDeferredDecorator(this, "message"), void 0);
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "QmtQZq+z",
+						"block": "[[[10,\"h2\"],[14,\"data-test-command-runner-greeting\",\"\"],[12],[8,[30,1,[\"message\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/tools-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class HelloCommand extends Tool {
+			static displayName = "HelloCommand";
+			async getInputType() {}
+			async run() {
+				return new GreetingCard({ message: "Hello from command runner" });
+			}
+		}
+		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, "lastName", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#lastName = (initializeDeferredDecorator(this, "lastName"), 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() {
+						if (!this.firstName) return;
+						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, this.lastName].filter(Boolean).join(" ");
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static isolated = class Isolated extends Component {
+				runScheduleMeetingCommand = async () => {
+					let toolContext = this.args.context?.toolContext;
+					if (!toolContext) {
+						console.error("No command context found");
+						return;
+					}
+					let scheduleMeeting = new ScheduleMeetingCommand(toolContext);
+					setOwner(scheduleMeeting, getOwner(this));
+					await scheduleMeeting.execute({
+						topic: "Meeting with Hassan",
+						participants: [this.args.model]
+					});
+				};
+				runOpenAiAssistantRoomCommand = async () => {
+					let toolContext = this.args.context?.toolContext;
+					if (!toolContext) {
+						console.error("No command context found");
+						return;
+					}
+					await new OpenAiAssistantRoomTool(toolContext).execute({ roomId: getRoomIds().pop() });
+				};
+				runMaybeBoomCommandViaAiAssistant = async () => {
+					let toolContext = this.args.context?.toolContext;
+					if (!toolContext) {
+						console.error("No command context found");
+						return;
+					}
+					let { roomId } = await new CreateAiAssistantRoomTool(toolContext).execute({
+						name: "AI Assistant Room",
+						enabledSkills: [await getService("store").get(`${testRealmURL}Skill/useful-commands`)]
+					});
+					await new SendAiAssistantMessageTool(toolContext).execute({
+						prompt: "Let's find out if it will boom",
+						roomId
+					});
+				};
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "dvMmt382",
+						"block": "[[[10,\"h2\"],[15,\"data-test-person\",[30,1,[\"firstName\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"firstName\"]],null,null,null],[1,\"\\n\"],[13],[1,\"\\n\"],[10,2],[15,\"data-test-first-letter-of-the-name\",[30,1,[\"firstLetterOfTheName\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"firstLetterOfTheName\"]],null,null,null],[1,\"\\n\"],[13],[1,\"\\nPet:\\n\"],[8,[30,2,[\"pet\"]],null,null,null],[1,\"\\nFriends:\\n\"],[8,[30,2,[\"friends\"]],null,null,null],[1,\"\\n\"],[11,\"button\"],[24,\"data-test-schedule-meeting-button\",\"\"],[4,[32,0],[\"click\",[30,0,[\"runScheduleMeetingCommand\"]]],null],[12],[1,\"Schedule meeting\"],[13],[1,\"\\n\"],[11,\"button\"],[24,\"data-test-open-ai-assistant-room-button\",\"\"],[4,[32,0],[\"click\",[30,0,[\"runOpenAiAssistantRoomCommand\"]]],null],[12],[1,\"Open AI Assistant Room\"],[13],[1,\"\\n\"],[11,\"button\"],[24,\"data-test-maybe-boom-via-ai-assistant\",\"\"],[4,[32,0],[\"click\",[30,0,[\"runMaybeBoomCommandViaAiAssistant\"]]],null],[12],[1,\"Maybe Boom\"],[13]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/tools-test.gts",
+						"scope": () => [on],
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class LinkEchoInput extends CardDef {
+			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);
+		}
+		let echoLinks = (input) => {
+			linkEchoProbe?.(input);
+			let message = `pet=${input.pet?.name ?? "none"}; friends=${(input.friends ?? []).map((friend) => friend.name).join(", ")}`;
+			linkEchoMessages.push(message);
+			return new GreetingCard({ message });
+		};
+		class LinkEchoCommand extends Tool {
+			static displayName = "LinkEchoCommand";
+			requireInputFields = ["pet"];
+			async getInputType() {
+				return LinkEchoInput;
+			}
+			async run(input) {
+				return echoLinks(input);
+			}
+		}
+		class UnexportedLinkEchoInput extends CardDef {
+			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);
+		}
+		class UnexportedLinkEchoCommand extends Tool {
+			static displayName = "UnexportedLinkEchoCommand";
+			async getInputType() {
+				return UnexportedLinkEchoInput;
+			}
+			async run(input) {
+				return echoLinks(input);
+			}
+		}
+		let mangoPet = new Pet({ name: "Mango" });
+		await setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"person.gts": {
+					Person,
+					Meeting
+				},
+				"pet.gts": { Pet },
+				"Pet/ringo.json": new Pet({ name: "Ringo" }),
+				"AiCommandExample/london.json": { data: {
+					type: "card",
+					attributes: { location: "London" },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}ai-command-example`,
+						name: "AiCommandExample"
+					} }
+				} },
+				"Person/hassan.json": new Person({
+					firstName: "Hassan",
+					lastName: "Abdel-Rahman",
+					pet: mangoPet,
+					friends: [mangoPet]
+				}),
+				"Pet/mango.json": mangoPet,
+				"Pet/vangogh.json": new Pet({ name: "Van Gogh" }),
+				"Person/fadhlan.json": new Person({
+					firstName: "Fadhlan",
+					pet: mangoPet,
+					friends: [mangoPet]
+				}),
+				"maybe-boom-command.ts": { default: MaybeBoomCommand },
+				"realm-viewer-command.ts": { default: RealmViewerCommand },
+				"command-runner-hello-command.ts": {
+					GreetingCard,
+					default: HelloCommand
+				},
+				"link-echo-command.ts": {
+					LinkEchoInput,
+					default: LinkEchoCommand
+				},
+				"unexported-link-echo-command.ts": { default: UnexportedLinkEchoCommand },
+				"search-and-open-card-command.ts": { default: SearchAndOpenCardCommand },
+				"Skill/useful-commands.json": { data: {
+					type: "card",
+					attributes: {
+						instructions: "Here are few commands you might find useful: * switch-submode: use this with \"code\" to go to code mode and \"interact\" to go to interact mode. * search-cards-by-type-and-title: search for cards by name or description.",
+						commands: [
+							{
+								codeRef: {
+									name: "SearchCardsByTypeAndTitleTool",
+									module: "@cardstack/boxel-host/commands/search-cards"
+								},
+								requiresApproval: true
+							},
+							{
+								codeRef: {
+									name: "default",
+									module: "@cardstack/boxel-host/commands/switch-submode"
+								},
+								requiresApproval: true
+							},
+							{
+								codeRef: {
+									name: "default",
+									module: `/test/maybe-boom-command`
+								},
+								requiresApproval: false
+							},
+							{
+								codeRef: {
+									name: "default",
+									module: "../search-and-open-card-command"
+								},
+								requiresApproval: true
+							}
+						],
+						cardTitle: "Useful Commands",
+						cardDescription: null,
+						cardThumbnailURL: null
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"Skill/link-echo.json": { data: {
+					type: "card",
+					attributes: {
+						instructions: "Use link-echo to name the pets you are given.",
+						commands: [{
+							codeRef: {
+								name: "default",
+								module: "../link-echo-command"
+							},
+							requiresApproval: true
+						}],
+						cardTitle: "Link echo",
+						cardDescription: null,
+						cardThumbnailURL: null
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"Skill/link-echo-unexported.json": { data: {
+					type: "card",
+					attributes: {
+						instructions: "Use link-echo to name the pets you are given.",
+						commands: [{
+							codeRef: {
+								name: "default",
+								module: "../unexported-link-echo-command"
+							},
+							requiresApproval: true
+						}],
+						cardTitle: "Link echo (unexported input)",
+						cardDescription: null,
+						cardThumbnailURL: null
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"Skill/realm-seeing.json": { data: {
+					type: "card",
+					attributes: {
+						instructions: "Use the realm viewer to look at a card.",
+						commands: [{
+							codeRef: {
+								name: "default",
+								module: "../realm-viewer-command"
+							},
+							requiresApproval: false
+						}],
+						cardTitle: "Realm seeing",
+						cardDescription: null,
+						cardThumbnailURL: null
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"Skill/seeing.json": { data: {
+					type: "card",
+					attributes: {
+						instructions: "Use view-visually to look at a card.",
+						commands: [{
+							codeRef: {
+								name: "default",
+								module: "@cardstack/boxel-host/tools/view-visually"
+							},
+							requiresApproval: false
+						}],
+						cardTitle: "Seeing",
+						cardDescription: null,
+						cardThumbnailURL: null
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"Skill/card-editing.json": { data: {
+					type: "card",
+					attributes: {
+						instructions: "Use show-card to bring a card into view once you know its id.",
+						commands: [{
+							codeRef: {
+								name: "default",
+								module: "@cardstack/boxel-host/commands/show-card"
+							},
+							requiresApproval: false
+						}],
+						cardTitle: "Card Editing",
+						cardDescription: null,
+						cardThumbnailURL: null
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"index.json": new CardsGrid(),
+				"realm.json": realmConfigCardJSON({
+					name: "Test Workspace B",
+					backgroundURL: "/test-fixtures/realm-images/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+					iconURL: "/test-fixtures/realm-images/boxel-logo.png"
+				}),
+				"skills/read-tools/SKILL.md": [
+					"---",
+					"name: read-tools",
+					"boxel:",
+					"  kind: skill",
+					"  tools:",
+					"    - codeRef:",
+					"        module: '@cardstack/boxel-host/commands/switch-submode'",
+					"        name: default",
+					"---",
+					"# Read Tools",
+					"",
+					"Use switch-submode to move between interact and code modes.",
+					""
+				].join("\n"),
+				"skills/decoy/SKILL.md": [
+					"---",
+					"name: decoy",
+					"boxel:",
+					"  kind: skill",
+					"  tools:",
+					"    - codeRef:",
+					"        module: /test/maybe-boom-command",
+					"        name: default",
+					"---",
+					"# Decoy",
+					"",
+					"Declares only maybe-boom.",
+					""
+				].join("\n"),
+				"hi.txt": "hi"
+			}
+		});
+	});
+	(0, import_qunit.test)("OpenAiAssistantRoomTool opens the AI assistant room", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}Person/hassan`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-schedule-meeting-button]");
+		await click("[data-test-open-ai-assistant-room-button]");
+		await waitFor("[data-room-settled]");
+		await waitFor("[data-test-room-name=\"AI Assistant Room\"]");
+		assert.dom("[data-test-ai-message-content]").includesText("Change the topic of the meeting to \"Meeting with Hassan\"");
+	});
+	(0, import_qunit.module)("command-runner", function() {
+		function setCommandRunnerRequest(requestId, nonce, command, input) {
+			window.localStorage.setItem(`boxel-command-request:${requestId}`, JSON.stringify({
+				command,
+				input,
+				nonce,
+				createdAt: Date.now()
+			}));
+		}
+		(0, import_qunit.test)("route renders command result card", async function(assert) {
+			let requestId = "command-runner-test-success";
+			let nonce = "1";
+			setCommandRunnerRequest(requestId, nonce, `${testRealmURL}command-runner-hello-command/default`, null);
+			await visit(`/command-runner/${requestId}/${nonce}`);
+			await waitFor("[data-prerender][data-prerender-status=\"ready\"]");
+			assert.dom("[data-test-command-runner-greeting]").includesText("Hello from command runner");
+		});
+		(0, import_qunit.test)("route captures command runtime error", async function(assert) {
+			maybeBoomShouldBoom = true;
+			let requestId = "command-runner-test-error";
+			let nonce = "2";
+			setCommandRunnerRequest(requestId, nonce, `${testRealmURL}maybe-boom-command/default`, null);
+			await visit(`/command-runner/${requestId}/${nonce}`);
+			await waitFor("[data-prerender][data-prerender-status=\"error\"]");
+			assert.dom("[data-prerender-error]").includesText("Boom!");
+			assert.dom("[data-test-command-runner-greeting]").doesNotExist();
+		});
+		(0, import_qunit.test)("resolves linksTo and linksToMany inputs specified by card id", async function(assert) {
+			let requestId = "command-runner-test-linksto";
+			let nonce = "3";
+			setCommandRunnerRequest(requestId, nonce, `${testRealmURL}link-echo-command/default`, {
+				pet: `${testRealmURL}Pet/ringo`,
+				friends: [`${testRealmURL}Pet/mango`, `${testRealmURL}Pet/vangogh`]
+			});
+			await visit(`/command-runner/${requestId}/${nonce}`);
+			await waitFor("[data-prerender][data-prerender-status=\"ready\"]");
+			assert.dom("[data-test-command-runner-greeting]").includesText("pet=Ringo");
+			assert.dom("[data-test-command-runner-greeting]").includesText("friends=Mango, Van Gogh");
+		});
+		(0, import_qunit.test)("captures an error when a linksTo input id cannot be resolved", async function(assert) {
+			let requestId = "command-runner-test-linksto-missing";
+			let nonce = "4";
+			setCommandRunnerRequest(requestId, nonce, `${testRealmURL}link-echo-command/default`, { pet: `${testRealmURL}Pet/does-not-exist` });
+			await visit(`/command-runner/${requestId}/${nonce}`);
+			await waitFor("[data-prerender][data-prerender-status=\"error\"]");
+			assert.dom("[data-prerender-error]").includesText("Pet/does-not-exist");
+			assert.dom("[data-test-command-runner-greeting]").doesNotExist();
+		});
+	});
+	(0, import_qunit.test)("SaveCardTool returns the saved card with its id set", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		const testCard = `${testRealmURL}Person/hassan`;
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click(`[data-test-stack-card="${testRealmURL}index"] [data-test-cards-grid-item="${testCard}"] .field-component-card`);
+		await click("[data-test-schedule-meeting-button]");
+		await waitUntil(() => savedMeetingCardId !== void 0);
+		assert.ok(savedMeetingCardId, "SaveCardTool returned the saved card");
+		assert.true(savedMeetingCardId.startsWith(testRealmURL), "saved card id is a URL within the test realm");
+	});
+	(0, import_qunit.test)("a scripted command can create a card, update it and show it", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		const testCard = `${testRealmURL}Person/hassan`;
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click(`[data-test-stack-card="${testRealmURL}index"] [data-test-cards-grid-item="${testCard}"] .field-component-card`);
+		await click("[data-test-schedule-meeting-button]");
+		await waitUntil(() => getRoomIds().length > 0);
+		let roomId = getRoomIds().pop();
+		let message = await waitUntil(() => {
+			let roomEvents = getRoomEvents(roomId);
+			for (let i = roomEvents.length - 1; i >= 0; i--) {
+				let event = roomEvents[i];
+				if (event.content.msgtype === "app.boxel.message") return event;
+			}
+		});
+		let meetingCardId = JSON.parse(message.content.data).attachedCards[0].sourceUrl;
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				name: "patchCardInstance",
+				id: "794c52f1-b444-47bd-8b2c-5d03ba7ef042",
+				arguments: JSON.stringify({
+					description: "Change the topic of the meeting to \"Meeting with Hassan\"",
+					attributes: {
+						cardId: meetingCardId,
+						patch: { attributes: { topic: "Meeting with Hassan" } }
+					}
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await click("[data-test-open-ai-assistant]");
+		getService("ai-assistant-panel-service").enterRoom(roomId);
+		await waitFor(`[data-room-id="${roomId}"][data-room-settled]`);
+		let applySelector = "[data-test-message-idx=\"1\"] [data-test-tool-call-apply]";
+		try {
+			await waitFor(applySelector, { timeout: 1e4 });
+		} catch (err) {
+			let messageIdxs = findAll("[data-test-message-idx]").map((el) => el.getAttribute("data-test-message-idx"));
+			let applyButtons = findAll("[data-test-tool-call-apply]").map((el) => el.getAttribute("data-test-tool-call-apply"));
+			let roomElements = findAll("[data-room-id]").map((el) => ({
+				roomId: el.getAttribute("data-room-id"),
+				settled: el.getAttribute("data-room-settled"),
+				roomName: el.getAttribute("data-test-room-name")
+			}));
+			let sessionPreparation = findAll("[data-test-session-preparation]").length;
+			let matrixService = getService("matrix-service");
+			let aiAssistantPanelService = getService("ai-assistant-panel-service");
+			let roomResource = matrixService.roomResources?.get?.(roomId);
+			let renderedRoomResource = matrixService.roomResources?.get?.(matrixService.currentRoomId);
+			let serviceState = {
+				currentRoomId: String(matrixService.currentRoomId ?? ""),
+				isLoadingTimeline: Boolean(matrixService.isLoadingTimeline),
+				isPreparingSession: Boolean(aiAssistantPanelService.isPreparingSession),
+				loadingRooms: Boolean(aiAssistantPanelService.loadingRooms),
+				aiSessionRoomIds: (aiAssistantPanelService.aiSessionRooms ?? []).map((r) => String(r.roomId ?? ""))
+			};
+			let resourceState = (label, r) => ({
+				label,
+				present: Boolean(r),
+				roomId: String(r?.roomId ?? ""),
+				hasMatrixRoom: Boolean(r?.matrixRoom),
+				memberIds: Array.isArray(r?.matrixRoom?.memberIds) ? r.matrixRoom.memberIds.map((m) => String(m)) : [],
+				hasRoomState: Boolean(r?.matrixRoom?.hasRoomState),
+				eventsCount: Number(r?.matrixRoom?.events?.length ?? 0),
+				messagesCount: Number(r?.messages?.length ?? 0),
+				isProcessing: Boolean(r?.isProcessing)
+			});
+			let roomEventsSummary = getRoomEvents(roomId).map((e) => ({
+				eventId: e.event_id,
+				type: e.type,
+				sender: e.sender,
+				stateKey: e.state_key,
+				msgtype: e.content?.msgtype,
+				hasCommandRequests: Array.isArray(e.content?.[APP_BOXEL_TOOL_REQUESTS_KEY])
+			}));
+			console.error("[scripted-command-test] apply button never rendered. Diagnostic:", JSON.stringify({
+				testRoomId: roomId,
+				renderedRoomElements: roomElements,
+				renderedMessageIdxs: messageIdxs,
+				renderedApplyButtonStates: applyButtons,
+				sessionPreparationElements: sessionPreparation,
+				serviceState,
+				resourceForTestRoom: resourceState("roomResources.get(testRoomId)", roomResource),
+				resourceForCurrentRoom: resourceState("roomResources.get(currentRoomId)", renderedRoomResource),
+				roomEvents: roomEventsSummary
+			}, null, 2));
+			throw err;
+		}
+		await click(applySelector);
+		await waitUntil(() => findAll("[data-test-operator-mode-stack]").length === 2);
+		assert.dom("[data-test-operator-mode-stack]").exists({ count: 2 });
+		assert.dom("[data-test-operator-mode-stack=\"1\"] [data-test-stack-card-index=\"0\"]").includesText("Meeting with Hassan");
+	});
+	(0, import_qunit.test)("a host command added from a skill can be executed when clicked on", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-room-settled]");
+		await addSkillToAiAssistant(`${testRealmURL}Skill/useful-commands`);
+		let roomId = getRoomIds().pop();
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "abc123",
+				name: "switch-submode_dd88",
+				arguments: JSON.stringify({
+					description: "Switching to code submode",
+					attributes: { submode: "code" }
+				})
+			}]
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] .tool-description").containsText("Switching to code submode");
+		await click("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await waitFor("[data-test-submode-switcher=code]", { timeout: 5e3 });
+		assert.dom("[data-test-submode-switcher=code]").exists();
+		await waitUntil(() => getRoomIds().length > 0 && getRoomEvents(roomId).find((m) => m.content.msgtype === "app.boxel.toolResultWithNoOutput"), {
+			timeout: 5e3,
+			timeoutMessage: "timed out waiting for command result event"
+		});
+		let message = getRoomEvents(roomId).find((m) => m.content.msgtype === APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE);
+		assert.strictEqual(message.content.msgtype, APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.rel_type, APP_BOXEL_TOOL_RESULT_REL_TYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.key, "applied");
+		assert.strictEqual(message.content.commandRequestId, "abc123");
+	});
+	(0, import_qunit.test)("a userland command added from a skill can be executed when clicked on", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-room-settled]");
+		await addSkillToAiAssistant(`${testRealmURL}Skill/useful-commands`);
+		let roomId = getRoomIds().pop();
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "29e8addb-197b-4d6d-b0a9-547959bf7c96",
+				name: buildCommandFunctionName({
+					module: testRRI("search-and-open-card-command"),
+					name: "default"
+				}, void 0, getService("network").virtualNetwork),
+				arguments: JSON.stringify({
+					description: "Finding and opening Hassan card",
+					attributes: { cardTitle: "Hassan" }
+				})
+			}]
+		});
+		await waitFor("[data-test-message-idx=\"0\"]");
+		assert.dom("[data-test-message-idx=\"0\"] .tool-description").containsText("Finding and opening Hassan card");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]").containsText("Search");
+		await click("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		assert.dom("[data-test-operator-mode-stack=\"1\"] [data-test-stack-card-index=\"0\"]").includesText("Person - Hassan Abdel-Rahman");
+		await waitUntil(() => getRoomIds().length > 0);
+		let message = getRoomEvents(roomId).pop();
+		assert.strictEqual(message.content.msgtype, APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.rel_type, APP_BOXEL_TOOL_RESULT_REL_TYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.key, "applied");
+		assert.strictEqual(message.content.commandRequestId, "29e8addb-197b-4d6d-b0a9-547959bf7c96");
+	});
+	function simulateSkillReadResult(roomId, sourceSkillUrl, functionName) {
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE,
+			commandRequestId: "read-1",
+			"m.relates_to": {
+				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+				key: "applied",
+				event_id: "earlier-bot-message"
+			},
+			data: {
+				attachedFiles: [],
+				discoveredTools: [{
+					sourceSkillUrl,
+					codeRef: {
+						module: "@cardstack/boxel-host/commands/switch-submode",
+						name: "default"
+					},
+					functionName,
+					requiresApproval: true,
+					definition: {
+						type: "function",
+						function: {
+							name: functionName,
+							description: "Switch between interact and code submodes",
+							parameters: {
+								type: "object",
+								properties: {}
+							}
+						}
+					}
+				}]
+			}
+		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+	}
+	(0, import_qunit.test)("a tool from a skill read via readRealmFile executes after approval", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-room-settled]");
+		let roomId = getRoomIds().pop();
+		simulateSkillReadResult(roomId, `${testRealmURL}skills/read-tools/SKILL.md`, "switch-submode_dd88");
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "call-1",
+				name: "switch-submode_dd88",
+				arguments: JSON.stringify({
+					description: "Switching to code submode",
+					attributes: { submode: "code" }
+				})
+			}]
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]").exists("the verified read-skill tool offers approval, not auto-run");
+		await click("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await waitFor("[data-test-submode-switcher=code]", { timeout: 5e3 });
+		assert.dom("[data-test-submode-switcher=code]").exists();
+		await waitUntil(() => getRoomEvents(roomId).find((m) => m.content.msgtype === "app.boxel.toolResultWithNoOutput" && m.content.commandRequestId === "call-1"), {
+			timeout: 5e3,
+			timeoutMessage: "timed out waiting for command result event"
+		});
+		let message = getRoomEvents(roomId).find((m) => m.content.msgtype === "app.boxel.toolResultWithNoOutput" && m.content.commandRequestId === "call-1");
+		assert.strictEqual(message.content["m.relates_to"]?.key, "applied");
+	});
+	(0, import_qunit.test)("a discovered-tool annotation naming a skill that does not declare the tool is rejected", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-room-settled]");
+		let roomId = getRoomIds().pop();
+		simulateSkillReadResult(roomId, `${testRealmURL}skills/decoy/SKILL.md`, "switch-submode_dd88");
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "call-forged",
+				name: "switch-submode_dd88",
+				arguments: JSON.stringify({
+					description: "Switching to code submode",
+					attributes: { submode: "code" }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-apply-state=\"invalid\"]").exists("the tool call is invalid");
+		assert.dom("[data-test-boxel-alert=\"warning\"]").containsText("No command for the name \"switch-submode_dd88\" was found");
+		assert.dom("[data-test-submode-switcher=code]").doesNotExist("the forged tool call never executed");
+		let message = toolResultFor(roomId, "call-forged");
+		assert.strictEqual(message.content.msgtype, APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.key, "invalid");
+	});
+	(0, import_qunit.test)("rendering a command request without a description fallsback to attributes.description", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-room-settled]");
+		await addSkillToAiAssistant(`${testRealmURL}Skill/useful-commands`);
+		simulateRemoteMessage(getRoomIds().pop(), "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "29e8addb-197b-4d6d-b0a9-547959bf7c96",
+				name: buildCommandFunctionName({
+					module: testRRI("search-and-open-card-command"),
+					name: "default"
+				}, void 0, getService("network").virtualNetwork),
+				arguments: JSON.stringify({ attributes: {
+					description: "Finding and opening Hassan card",
+					title: "Hassan"
+				} })
+			}]
+		});
+		await waitFor("[data-test-message-idx=\"0\"]");
+		assert.dom("[data-test-message-idx=\"0\"] .tool-description").containsText("Finding and opening Hassan card");
+	});
+	(0, import_qunit.test)("command description is visible while tool call is preparing", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-room-settled]");
+		await addSkillToAiAssistant(`${testRealmURL}Skill/useful-commands`);
+		let roomId = getRoomIds().pop();
+		let description = "Switching to code submode during preparation";
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "preparing-command-id",
+				name: "switch-submode_dd88",
+				arguments: JSON.stringify({
+					description,
+					attributes: { submode: "code" }
+				})
+			}]
+		});
+		await waitFor("[data-test-message-idx=\"0\"]");
+		assert.dom("[data-test-message-idx=\"0\"] .tool-description").containsText(description);
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"preparing\"]").exists();
+	});
+	(0, import_qunit.test)("ShowCard command added from a skill, can be automatically executed when agentId matches", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		let roomId = getRoomIds().pop();
+		await waitFor("[data-test-message-field]");
+		await fillIn("[data-test-message-field]", "Test message to enable new session button");
+		await click("[data-test-send-message-btn]");
+		await click("[data-test-create-room-btn]");
+		roomId = getRoomIds().pop();
+		await addSkillToAiAssistant(`${testRealmURL}Skill/card-editing`);
+		await waitForNewRoomSkillsLoaded(roomId);
+		let toolCallId = "1554f297-e9f2-43fe-8b95-55b29251444d";
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "Show the card",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: toolCallId,
+				name: showCardToolName,
+				arguments: JSON.stringify({
+					description: "Displaying the card with the Latin word for milkweed in the title.",
+					attributes: {
+						cardId: `${testRealmURL}Person/hassan`,
+						cardInfo: { name: "Asclepias" }
+					}
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-apply-state=\"applied\"]").exists(describeToolResult(roomId, toolCallId));
+		assert.dom("[data-test-tool-call-id]").doesNotHaveClass("is-failed");
+		assert.dom("[data-test-submode-switcher=interact]").exists();
+		assert.dom("[data-test-operator-mode-stack=\"1\"] [data-test-stack-card-index=\"0\"]").includesText("Person - Hassan Abdel-Rahman");
+		await waitUntil(() => getRoomIds().length > 0);
+		let message = toolResultFor(roomId, toolCallId);
+		assert.strictEqual(message.content.msgtype, APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.rel_type, APP_BOXEL_TOOL_RESULT_REL_TYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.key, "applied");
+		assert.strictEqual(message.content.commandRequestId, "1554f297-e9f2-43fe-8b95-55b29251444d");
+	});
+	(0, import_qunit.test)("a view-visually result attaches the capture to the tool result event for the model", async function(assert) {
+		const png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==";
+		registerRealmServerRoute({
+			path: "/_capture",
+			handler: async () => new Response(JSON.stringify({ data: {
+				type: "capture-result",
+				attributes: {
+					status: "ready",
+					base64: png,
+					width: 1,
+					height: 1,
+					contentType: "image/png"
+				}
+			} }), {
+				status: 201,
+				headers: { "Content-Type": "application/vnd.api+json" }
+			})
+		});
+		try {
+			await visitOperatorMode({
+				stacks: [[{
+					id: `${testRealmURL}index`,
+					format: "isolated"
+				}]],
+				aiAssistantOpen: true
+			});
+			await waitFor("[data-test-message-field]");
+			await fillIn("[data-test-message-field]", "Start a session");
+			await click("[data-test-send-message-btn]");
+			await click("[data-test-create-room-btn]");
+			let roomId = getRoomIds().pop();
+			await addSkillToAiAssistant(`${testRealmURL}Skill/seeing`);
+			await waitForNewRoomSkillsLoaded(roomId);
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "Looking at the card",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+					id: "view-visually-handoff",
+					name: viewVisuallyToolName,
+					arguments: JSON.stringify({
+						description: "Look at the card",
+						attributes: { url: `${testRealmURL}Person/hassan` }
+					})
+				}],
+				data: { context: { agentId: getService("matrix-service").agentId } }
+			});
+			await settled();
+			assert.dom("[data-test-message-idx=\"0\"] [data-test-apply-state=\"applied\"]").exists(describeToolResult(roomId, "view-visually-handoff"));
+			let result = getRoomEvents(roomId).filter((event) => event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content.commandRequestId === "view-visually-handoff").pop();
+			assert.strictEqual(result.content["m.relates_to"]?.key, "applied");
+			let attachedFiles = JSON.parse(result.content.data).attachedFiles;
+			assert.strictEqual(attachedFiles.length, 1, "one image is attached");
+			assert.strictEqual(attachedFiles[0].contentType, "image/png");
+			assert.ok(attachedFiles[0].url, "the image names its uploaded media");
+			assert.strictEqual(typeof attachedFiles[0].contentSize, "number", "the image records its size, which the prompt needs to send it");
+		} finally {
+			unregisterRealmServerRoute("/_capture");
+		}
+	});
+	(0, import_qunit.test)("a command loaded from a realm attaches nothing to its tool result, even one built on a host tool", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-test-message-field]");
+		await fillIn("[data-test-message-field]", "Start a session");
+		await click("[data-test-send-message-btn]");
+		await click("[data-test-create-room-btn]");
+		let roomId = getRoomIds().pop();
+		await addSkillToAiAssistant(`${testRealmURL}Skill/realm-seeing`);
+		await waitForNewRoomSkillsLoaded(roomId);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "Looking at the card",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "realm-viewer-request",
+				name: buildCommandFunctionName({
+					module: testRRI("realm-viewer-command"),
+					name: "default"
+				}, void 0, getService("network").virtualNetwork),
+				arguments: JSON.stringify({
+					description: "Look at the card",
+					attributes: { url: `${testRealmURL}Pet/mango` }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-apply-state=\"applied\"]").exists(describeToolResult(roomId, "realm-viewer-request"));
+		let result = getRoomEvents(roomId).filter((event) => event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content.commandRequestId === "realm-viewer-request").pop();
+		assert.strictEqual(result.content["m.relates_to"]?.key, "applied");
+		let data = JSON.parse(result.content.data);
+		assert.deepEqual(data.attachedFiles, [], "the image its result names is not attached for the model");
+	});
+	(0, import_qunit.test)("ShowCard command added from a skill, is not automatically executed when agentId does not match", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		let roomId = getRoomIds().pop();
+		await waitFor("[data-test-message-field]");
+		await fillIn("[data-test-message-field]", "Test message to enable new session button");
+		await click("[data-test-send-message-btn]");
+		await click("[data-test-create-room-btn]");
+		roomId = getRoomIds().pop();
+		await addSkillToAiAssistant(`${testRealmURL}Skill/card-editing`);
+		await waitForNewRoomSkillsLoaded(roomId);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "Show the card",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "1554f297-e9f2-43fe-8b95-55b29251444d",
+				name: showCardToolName,
+				arguments: JSON.stringify({
+					description: "Displaying the card with the Latin word for milkweed in the title.",
+					attributes: {
+						id: `${testRealmURL}Person/hassan`,
+						title: "Asclepias"
+					}
+				})
+			}],
+			data: { context: { agentId: "some-other-agent-id" } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-apply-state=\"ready\"]").exists();
+		assert.dom("[data-test-tool-call-id]").doesNotHaveClass("is-failed");
+		assert.dom("[data-test-submode-switcher=interact]").exists();
+	});
+	(0, import_qunit.test)("multiple commands can be requested in a single aibot message", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-room-settled]");
+		await addSkillToAiAssistant(`${testRealmURL}Skill/useful-commands`);
+		simulateRemoteMessage(getRoomIds().pop(), "@aibot:localhost", {
+			body: "Checking the current UI state and searching for cards",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "a4237eca-b73e-4256-bf3a-45849fa07d02",
+				name: "switch-submode_dd88",
+				arguments: JSON.stringify({ attributes: { submode: "code" } })
+			}, {
+				id: "2b48526b-d599-4789-a47b-dff349948c37",
+				name: "search-cards-by-type-and-title_dd88",
+				arguments: JSON.stringify({ attributes: { query: "test" } })
+			}]
+		});
+		await waitFor("[data-test-message-idx=\"0\"]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]").exists({ count: 2 });
+	});
+	(0, import_qunit.test)("LLM mode event controls auto-apply of switch-submode command with timestamp checking", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor(`[data-room-settled]`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/useful-commands`);
+		await click("[data-test-skill-menu]");
+		await click("[data-test-skill-menu] [data-test-pill-menu-header] [data-test-pill-menu-button]");
+		assert.dom("[data-test-llm-mode-option=\"ask\"]").hasClass("selected");
+		let commandId = "switch-submode-cmd-1";
+		simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			body: "Switch to code mode",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: commandId,
+				name: "switch-submode_dd88",
+				arguments: JSON.stringify({
+					description: "switch to code mode",
+					attributes: { submode: "code" }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-apply-state=\"ready\"]").exists("Apply button is shown in ask mode");
+		assert.dom("[data-test-apply-state=\"applied\"]").doesNotExist("Command is not auto-applied in ask mode");
+		await click("[data-test-llm-mode-option=\"act\"]");
+		assert.dom("[data-test-llm-mode-option=\"act\"]").hasClass("selected");
+		let llmModeState = getRoomState(matrixRoomId, APP_BOXEL_LLM_MODE, "");
+		assert.strictEqual(llmModeState?.mode, "act", "LLM mode updates to act");
+		let commandId2 = "switch-submode-cmd-2";
+		simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			body: "Switch to interact mode",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: commandId2,
+				name: "switch-submode_dd88",
+				arguments: JSON.stringify({
+					description: "switch to interact mode",
+					attributes: { submode: "interact" }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"1\"] [data-test-apply-state=\"applied\"]").exists(`Command is auto-applied in act mode: ${describeToolResult(matrixRoomId, commandId2)}`);
+		await click("[data-test-llm-mode-option=\"ask\"]");
+		assert.dom("[data-test-llm-mode-option=\"ask\"]").hasClass("selected");
+		let commandId3 = "switch-submode-cmd-3";
+		simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			body: "Switch to code mode again",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: commandId3,
+				name: "switch-submode_dd88",
+				arguments: JSON.stringify({
+					description: "switch to code mode",
+					attributes: { submode: "code" }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"2\"] [data-test-apply-state=\"ready\"]").exists("Apply button is shown in ask mode");
+		assert.dom("[data-test-message-idx=\"2\"] [data-test-apply-state=\"applied\"]").doesNotExist("Command is not auto-applied in ask mode");
+		await click("[data-test-llm-mode-option=\"act\"]");
+		assert.dom("[data-test-llm-mode-option=\"act\"]").hasClass("selected");
+		assert.dom("[data-test-message-idx=\"2\"] [data-test-apply-state=\"ready\"]").exists("Apply button is still shown for command sent before act mode");
+		assert.dom("[data-test-message-idx=\"2\"] [data-test-apply-state=\"applied\"]").doesNotExist("Command sent before act mode is not auto-applied");
+		let commandId4 = "switch-submode-cmd-4";
+		simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			body: "Switch to interact mode again",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: commandId4,
+				name: "switch-submode_dd88",
+				arguments: JSON.stringify({
+					description: "switch to interact mode",
+					attributes: { submode: "interact" }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"3\"] [data-test-apply-state=\"applied\"]").exists(`New command sent after act mode is auto-applied: ${describeToolResult(matrixRoomId, commandId4)}`);
+	});
+	(0, import_qunit.test)("command request with invalid name gets an \"invalid\" result", async function(assert) {
+		await visitOperatorMode({
+			aiAssistantOpen: true,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await waitFor("[data-test-message-field]");
+		await fillIn("[data-test-message-field]", "Test message to enable new session button");
+		await click("[data-test-send-message-btn]");
+		await click("[data-test-create-room-btn]");
+		let roomId = getRoomIds().pop();
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "Show the card",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "1554f297-e9f2-43fe-8b95-55b29251444d",
+				name: "no-such-command",
+				arguments: JSON.stringify({
+					description: "Displaying the card with the Latin word for milkweed in the title.",
+					attributes: {
+						id: `${testRealmURL}Person/hassan`,
+						title: "Asclepias"
+					}
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-apply-state=\"invalid\"]").exists("the tool call is invalid");
+		assert.dom("[data-test-boxel-alert=\"warning\"]").containsText("No command for the name \"no-such-command\" was found");
+		assert.dom("[data-test-tool-call-id]").doesNotHaveClass("is-failed");
+		let message = toolResultFor(roomId, "1554f297-e9f2-43fe-8b95-55b29251444d");
+		assert.strictEqual(message.content.msgtype, APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.rel_type, APP_BOXEL_TOOL_RESULT_REL_TYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.key, "invalid");
+		assert.strictEqual(message.content.failureReason, "No command for the name \"no-such-command\" was found");
+		assert.strictEqual(message.content.commandRequestId, "1554f297-e9f2-43fe-8b95-55b29251444d");
+	});
+	(0, import_qunit.test)("a tool request without the description label still validates and runs", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-test-message-field]");
+		await fillIn("[data-test-message-field]", "Test message to enable new session button");
+		await click("[data-test-send-message-btn]");
+		await click("[data-test-create-room-btn]");
+		let roomId = getRoomIds().pop();
+		await addSkillToAiAssistant(`${testRealmURL}Skill/card-editing`);
+		await waitForNewRoomSkillsLoaded(roomId);
+		let toolCallId = "no-description-request";
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "Show the card",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: toolCallId,
+				name: showCardToolName,
+				arguments: JSON.stringify({ attributes: { cardId: `${testRealmURL}Person/hassan` } })
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-apply-state=\"applied\"]").exists(describeToolResult(roomId, toolCallId));
+		assert.dom("[data-test-boxel-alert=\"warning\"]").doesNotExist();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-code-block]").containsText("Show card", "the pill label falls back to the tool name");
+		let message = toolResultFor(roomId, toolCallId);
+		assert.strictEqual(message.content["m.relates_to"]?.key, "applied");
+		assert.strictEqual(message.content.commandRequestId, toolCallId);
+	});
+	(0, import_qunit.test)("command request with arguments that do not match the json schema gets an \"invalid\" result", async function(assert) {
+		await visitOperatorMode({
+			aiAssistantOpen: true,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await waitFor("[data-test-message-field]");
+		await fillIn("[data-test-message-field]", "Test message to enable new session button");
+		await click("[data-test-send-message-btn]");
+		await click("[data-test-create-room-btn]");
+		let roomId = getRoomIds().pop();
+		await addSkillToAiAssistant(`${testRealmURL}Skill/card-editing`);
+		await waitForNewRoomSkillsLoaded(roomId);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "Show the card",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "1554f297-e9f2-43fe-8b95-55b29251444d",
+				name: showCardToolName,
+				arguments: JSON.stringify({
+					description: "Displaying the card with the Latin word for milkweed in the title.",
+					attributes: { title: "Asclepias" }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-apply-state=\"invalid\"]").exists("the tool call is invalid");
+		let expectedValidationText = `Command "${showCardToolName}" validation failed: data/attributes must have required property 'cardId'`;
+		let warningText = document.querySelector("[data-test-boxel-alert=\"warning\"]")?.textContent?.trim() ?? "";
+		if (!warningText.includes(expectedValidationText)) {
+			let roomData = getService("matrix-service").getRoomData(roomId);
+			let roomResource = getService("matrix-service").roomResources.get(roomId);
+			console.error("[commands-test/json-schema-validation] warning text mismatch. Diagnostic:", JSON.stringify({
+				roomId,
+				warningText,
+				enabledSkillCards: roomData?.skillsConfig?.enabledSkillCards?.map((f) => f.sourceUrl) ?? null,
+				roomResourceCommandCount: roomResource?.tools?.length ?? null
+			}, null, 2));
+		}
+		assert.dom("[data-test-boxel-alert=\"warning\"]").containsText(expectedValidationText);
+		assert.dom("[data-test-tool-call-id]").doesNotHaveClass("is-failed");
+		let message = toolResultFor(roomId, "1554f297-e9f2-43fe-8b95-55b29251444d");
+		assert.strictEqual(message.content.msgtype, APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.rel_type, APP_BOXEL_TOOL_RESULT_REL_TYPE);
+		assert.strictEqual(message.content["m.relates_to"]?.key, "invalid");
+		assert.strictEqual(message.content.failureReason, expectedValidationText);
+		assert.strictEqual(message.content.commandRequestId, "1554f297-e9f2-43fe-8b95-55b29251444d");
+	});
+	async function requestLinkEcho(relationships, { tool = "link-echo" } = {}) {
+		let skill = tool === "link-echo" ? "Skill/link-echo" : "Skill/link-echo-unexported";
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}${skill}`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor("[data-room-settled]");
+		await addSkillToAiAssistant(`${testRealmURL}${skill}`);
+		let roomId = getRoomIds().pop();
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "link-echo-request",
+				name: buildCommandFunctionName({
+					module: testRRI(`${tool}-command`),
+					name: "default"
+				}, void 0, getService("network").virtualNetwork),
+				arguments: JSON.stringify({
+					description: "Naming the pets",
+					attributes: {},
+					relationships
+				})
+			}]
+		});
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await settled();
+		return roomId;
+	}
+	function linkEchoResult(roomId) {
+		return getRoomEvents(roomId).find((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "link-echo-request");
+	}
+	async function applyLinkEcho(roomId) {
+		await click("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await waitUntil(() => linkEchoResult(roomId), {
+			timeout: 5e3,
+			timeoutMessage: "timed out waiting for the link-echo result"
+		});
+		return linkEchoResult(roomId);
+	}
+	const allPets = {
+		pet: { links: { self: `${testRealmURL}Pet/ringo` } },
+		friends: [{ links: { self: `${testRealmURL}Pet/mango` } }, { links: { self: `${testRealmURL}Pet/vangogh` } }]
+	};
+	(0, import_qunit.test)("a tool runs with the linked inputs it was given once they load", async function(assert) {
+		let roomId = await requestLinkEcho(allPets);
+		let store = getService("store");
+		let petIds = [
+			"ringo",
+			"mango",
+			"vangogh"
+		].map((name) => `${testRealmURL}Pet/${name}`);
+		for (let id of petIds) assert.strictEqual(store.peek(id), void 0, `${id} is not in the store before the tool runs`);
+		let duringRun;
+		linkEchoProbe = (input) => {
+			store.store.sweep(card_api_exports);
+			store.store.sweep(card_api_exports);
+			let inputId = input[localId];
+			duringRun = {
+				inputId,
+				references: store.getReferenceCount(inputId),
+				resident: petIds.map((id) => store.peek(id) !== void 0)
+			};
+		};
+		let result = await applyLinkEcho(roomId);
+		assert.strictEqual(result.content["m.relates_to"]?.key, "applied");
+		assert.deepEqual(linkEchoMessages, ["pet=Ringo; friends=Mango, Van Gogh"]);
+		assert.strictEqual(duringRun.references, 1, "the call holds its input while the tool runs");
+		assert.deepEqual(duringRun.resident, [
+			true,
+			true,
+			true
+		], "the linked pets survive garbage collection while the tool runs");
+		await waitUntil(() => store.getReferenceCount(duringRun.inputId) === 0, { timeoutMessage: "the call did not release its input" });
+	});
+	(0, import_qunit.test)("a tool waits only on its own linked inputs, not on other loads in the store", async function(assert) {
+		let roomId = await requestLinkEcho(allPets);
+		let unrelatedLoad = new Deferred();
+		getService("store").trackLoad(unrelatedLoad.promise);
+		try {
+			let result = await applyLinkEcho(roomId);
+			assert.strictEqual(result.content["m.relates_to"]?.key, "applied");
+			assert.deepEqual(linkEchoMessages, ["pet=Ringo; friends=Mango, Van Gogh"]);
+		} finally {
+			unrelatedLoad.fulfill();
+		}
+	});
+	(0, import_qunit.test)("a tool whose linked input is already in the store runs with it", async function(assert) {
+		await getService("store").get(`${testRealmURL}Pet/ringo`);
+		let result = await applyLinkEcho(await requestLinkEcho({ pet: { links: { self: `${testRealmURL}Pet/ringo` } } }));
+		assert.strictEqual(result.content["m.relates_to"]?.key, "applied");
+		assert.deepEqual(linkEchoMessages, ["pet=Ringo; friends="]);
+	});
+	(0, import_qunit.test)("a linked input that does not exist makes the call invalid, naming the field and the card", async function(assert) {
+		let missing = `${testRealmURL}Pet/does-not-exist`;
+		let result = await applyLinkEcho(await requestLinkEcho({ pet: { links: { self: missing } } }));
+		assert.strictEqual(result.content["m.relates_to"]?.key, "invalid");
+		assert.true(result.content.failureReason.startsWith(`Could not load pet "${missing}" (not-found`), `failure names the field and the card, got: ${result.content.failureReason}`);
+		assert.deepEqual(linkEchoMessages, [], "the tool did not run");
+	});
+	(0, import_qunit.test)("one missing card in a plural linked input makes the call invalid, naming only that card", async function(assert) {
+		let missing = `${testRealmURL}Pet/does-not-exist`;
+		let result = await applyLinkEcho(await requestLinkEcho({
+			pet: { links: { self: `${testRealmURL}Pet/ringo` } },
+			friends: [{ links: { self: `${testRealmURL}Pet/mango` } }, { links: { self: missing } }]
+		}));
+		assert.strictEqual(result.content["m.relates_to"]?.key, "invalid");
+		assert.true(result.content.failureReason.startsWith(`Could not load friends "${missing}" (not-found`), `failure names the missing card, got: ${result.content.failureReason}`);
+		assert.false(result.content.failureReason.includes("Pet/mango"), "the card that loaded is not named");
+		assert.deepEqual(linkEchoMessages, [], "the tool did not run");
+	});
+	(0, import_qunit.test)("a call that leaves out a required linked input is invalid", async function(assert) {
+		let result = await applyLinkEcho(await requestLinkEcho(void 0));
+		assert.strictEqual(result.content["m.relates_to"]?.key, "invalid");
+		assert.true(result.content.failureReason.startsWith("Missing pet"), `failure names the missing field, got: ${result.content.failureReason}`);
+		assert.deepEqual(linkEchoMessages, [], "the tool did not run");
+	});
+	(0, import_qunit.test)("a call that gives a required linked input an empty link is invalid", async function(assert) {
+		let result = await applyLinkEcho(await requestLinkEcho({ pet: { links: { self: "" } } }));
+		assert.strictEqual(result.content["m.relates_to"]?.key, "invalid");
+		assert.true(result.content.failureReason.startsWith("Missing pet"), `failure names the missing field, got: ${result.content.failureReason}`);
+		assert.deepEqual(linkEchoMessages, [], "the tool did not run");
+	});
+	(0, import_qunit.test)("a tool whose input class is not exported runs with its linked inputs once they load", async function(assert) {
+		let result = await applyLinkEcho(await requestLinkEcho(allPets, { tool: "unexported-link-echo" }));
+		assert.strictEqual(result.content["m.relates_to"]?.key, "applied");
+		assert.deepEqual(linkEchoMessages, ["pet=Ringo; friends=Mango, Van Gogh"]);
+	});
+	(0, import_qunit.test)("a tool whose input class is not exported reports a linked input that does not exist", async function(assert) {
+		let missing = `${testRealmURL}Pet/does-not-exist`;
+		let result = await applyLinkEcho(await requestLinkEcho({ pet: { links: { self: missing } } }, { tool: "unexported-link-echo" }));
+		assert.strictEqual(result.content["m.relates_to"]?.key, "invalid");
+		assert.true(result.content.failureReason.startsWith(`Could not load pet "${missing}" (not-found`), `failure names the field and the card, got: ${result.content.failureReason}`);
+		assert.deepEqual(linkEchoMessages, [], "the tool did not run");
+	});
+	(0, import_qunit.module)("suspending global error hook", (hooks) => {
+		suspendGlobalErrorHook(hooks);
+		(0, import_qunit.test)("a command that errors when executing allows retry", async function(assert) {
+			await visitOperatorMode({ stacks: [[{
+				id: `${testRealmURL}Person/hassan`,
+				format: "isolated"
+			}]] });
+			await click("[data-test-maybe-boom-via-ai-assistant]");
+			await waitUntil(() => getRoomIds().length > 0);
+			await click("[data-test-open-ai-assistant-room-button]");
+			let roomId = getRoomIds().pop();
+			maybeBoomShouldBoom = true;
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "Will it boom?",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+					id: "2dd27b90-b473-403c-a5ae-399a29af7d62",
+					name: "maybe-boom-command_4b30",
+					arguments: JSON.stringify({
+						description: "Maybe it will boom",
+						attributes: {}
+					})
+				}],
+				data: { context: { agentId: getService("matrix-service").agentId } }
+			});
+			await settled();
+			let failedResultEvents = await getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.key === "failed");
+			assert.strictEqual(failedResultEvents.length, 1, "failed command result event dispatched");
+			let appliedResultEvents = await getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.key === "applied");
+			assert.strictEqual(appliedResultEvents.length, 0, "no applied command result event dispatched");
+			maybeBoomShouldBoom = false;
+			await click("[data-test-alert-action-button=\"Retry\"]");
+			appliedResultEvents = await getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.key === "applied");
+			assert.strictEqual(appliedResultEvents.length, 1, "applied command result event was dispatched after retry");
+			assert.dom("[data-test-apply-state=\"applied\"]").exists();
+		});
+	});
+});
+//#endregion