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

package/bundled-test-harness/assets/select-BiQTg2ts.js

@@ -0,0 +1,175 @@
+import "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Vn as guidFor, et as tracked, wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { _t as schedule } from "./service-LFpJ8EEP.js";
+import { H as templateFactory, S as on } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./tracking-CNiq91Pk.js";
+import "./modifier-D0EP-FQ7.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { w as BoxelSelect } from "./components-Ck24ubaT.js";
+import { r as modifier } from "./dist-nMt-N14r.js";
+import "./internals-BTorg710.js";
+import { t as consume } from "./dist-Ble0L9o7.js";
+import { i as firstDefined, r as emit } from "./pretui-primitives-CRs8NRm0.js";
+import { t as POPUPS_IN_PLACE } from "./overlay-D2rQi8lJ.js";
+import { t as IconComponent } from "./search-BDcFn7oI.js";
+//#region ../pretui/components/select.gts
+var SelectIconFace = setComponentTemplate(templateFactory({
+	"id": "N+KY4qpP",
+	"block": "[[[8,[30,1],[[24,\"width\",\"1.25em\"],[24,\"height\",\"1.25em\"],[24,\"aria-hidden\",\"true\"]],null,null]],[\"@icon\"],[]]",
+	"moduleName": "/home/runner/work/boxel/boxel/packages/pretui/components/select.gts",
+	"isStrictMode": true
+}), templateOnly());
+var PoweredSelect = BoxelSelect;
+var nameFromLabel = modifier((wrap, [controlId, explicit, tailId]) => {
+	if (explicit) return;
+	let trigger = wrap.querySelector("[data-pretui-select-trigger]");
+	if (!trigger) return;
+	let label = (controlId ? document.querySelector(`label[for="${CSS.escape(controlId)}"]`) : null) ?? wrap.closest("label");
+	if (!label) return;
+	if (!label.id) label.id = `${trigger.id}-label`;
+	trigger.setAttribute("aria-labelledby", `${label.id} ${tailId ?? trigger.id}`);
+});
+var LIST_WINDOW_MARGIN = 8;
+var SelectSearch = class extends Component {
+	fitList = modifier((marker) => {
+		let list = marker.closest(".ember-power-select-dropdown");
+		if (!list) return;
+		for (let { name } of [...marker.attributes]) if (name.startsWith("data-scopedcss-")) list.setAttribute(name, "");
+		let frame = requestAnimationFrame(() => {
+			let { left, right } = list.getBoundingClientRect();
+			let edge = document.documentElement.clientWidth - LIST_WINDOW_MARGIN;
+			if (left >= LIST_WINDOW_MARGIN && right > edge) {
+				let room = `${Math.floor(edge - left)}px`;
+				list.style.setProperty("min-width", room);
+				list.style.setProperty("max-width", room);
+				this.args.select.actions.reposition?.();
+			}
+		});
+		return () => cancelAnimationFrame(frame);
+	});
+	handleInput = (e) => {
+		this.args.onInput(e);
+	};
+	handleKeydown = (e) => {
+		if (this.args.onKeydown(e) === false) return;
+		if (e instanceof KeyboardEvent && e.key === "Enter") this.args.select.actions.close(e);
+	};
+	focusOnOpen = modifier((el) => {
+		let frame = requestAnimationFrame(() => el.focus());
+		return () => {
+			cancelAnimationFrame(frame);
+			this.args.select.actions.search("");
+		};
+	});
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "yoUpe6bA",
+			"block": "[[[11,1],[24,0,\"pretui-selectlist-scope\"],[24,\"hidden\",\"\"],[24,\"data-scopedcss-ec1bbf807a-8a27732a85\",\"\"],[4,[30,0,[\"fitList\"]],null,null],[12],[13],[1,\"\\n\"],[41,[30,1],[[[1,\"  \"],[11,0],[24,0,\"ember-power-select-search pretui-selectsearch\"],[24,\"data-test-pretui-select-search\",\"\"],[17,2],[24,\"data-scopedcss-ec1bbf807a-8a27732a85\",\"\"],[12],[1,\"\\n    \"],[8,[32,0],[[24,0,\"pretui-selectsearch-icon\"],[24,\"width\",\"16\"],[24,\"height\",\"16\"],[24,\"aria-hidden\",\"true\"],[24,\"data-scopedcss-ec1bbf807a-8a27732a85\",\"\"]],null,null],[1,\"\\n\"],[1,\"    \"],[11,\"input\"],[24,0,\"ember-power-select-search-input\"],[16,2,[30,3,[\"searchText\"]]],[24,\"placeholder\",\"Search…\"],[24,\"autocomplete\",\"off\"],[24,\"autocorrect\",\"off\"],[24,\"autocapitalize\",\"off\"],[24,\"spellcheck\",\"false\"],[24,\"role\",\"combobox\"],[16,\"aria-activedescendant\",[30,4]],[16,\"aria-controls\",[30,5]],[16,\"aria-owns\",[30,5]],[24,\"aria-autocomplete\",\"list\"],[24,\"aria-haspopup\",\"listbox\"],[16,\"aria-expanded\",[52,[30,3,[\"isOpen\"]],\"true\",\"false\"]],[16,\"aria-label\",[52,[30,6],[30,6],\"Search options\"]],[16,\"aria-labelledby\",[30,7]],[16,\"aria-describedby\",[30,8]],[24,\"data-test-pretui-select-search-input\",\"\"],[24,\"data-scopedcss-ec1bbf807a-8a27732a85\",\"\"],[24,4,\"search\"],[4,[32,1],[\"input\",[30,0,[\"handleInput\"]]],null],[4,[32,1],[\"keydown\",[30,0,[\"handleKeydown\"]]],null],[4,[32,1],[\"focus\",[30,9]],null],[4,[32,1],[\"blur\",[30,10]],null],[4,[30,0,[\"focusOnOpen\"]],null,null],[12],[13],[1,\"\\n  \"],[13],[1,\"\\n\"]],[]],null]],[\"@searchEnabled\",\"&attrs\",\"@select\",\"@ariaActiveDescendant\",\"@listboxId\",\"@ariaLabel\",\"@ariaLabelledBy\",\"@ariaDescribedBy\",\"@onFocus\",\"@onBlur\"],[\"if\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/pretui/components/select.gts",
+			"scope": () => [IconComponent, on],
+			"isStrictMode": true
+		}), this);
+	}
+};
+var Select = class extends Component {
+	static {
+		decorateFieldV2(this.prototype, "internal", [tracked], function() {
+			return this.args.defaultValue;
+		});
+	}
+	#internal = (initializeDeferredDecorator(this, "internal"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "popupsInPlace", [consume(POPUPS_IN_PLACE)]);
+	}
+	#popupsInPlace = (initializeDeferredDecorator(this, "popupsInPlace"), void 0);
+	keepFocusInList = modifier((wrap) => {
+		let onPress = (e) => {
+			let target = e.target;
+			if (target?.closest("input")) return;
+			if (target?.closest("[role='listbox'], [data-option-index]")) e.preventDefault();
+		};
+		wrap.addEventListener("mousedown", onPress);
+		return () => wrap.removeEventListener("mousedown", onPress);
+	});
+	wrap = null;
+	trackWrap = modifier((wrap) => {
+		this.wrap = wrap;
+		return () => {
+			this.wrap = null;
+		};
+	});
+	matchListType = (select) => {
+		schedule("afterRender", () => {
+			let trigger = this.wrap?.querySelector("[data-pretui-select-trigger]");
+			let list = document.getElementById(`ember-basic-dropdown-content-${select.uniqueId}`);
+			if (!trigger || !list) return;
+			let style = getComputedStyle(trigger);
+			for (let name of ["--pretui-select-list-font-size", "--pretui-select-list-line-height"]) list.style.setProperty(name, style.getPropertyValue(name));
+			select.actions.reposition();
+		});
+	};
+	get explicitName() {
+		return this.args.label !== void 0 || this.args.labelledBy !== void 0;
+	}
+	get iconFace() {
+		return this.args.display === "icon" ? this.args.icon : void 0;
+	}
+	get iconValue() {
+		return this.selectedOption?.label ?? this.args.placeholder ?? "Select…";
+	}
+	get iconName() {
+		if (!this.iconFace) return;
+		return this.args.label ? `${this.args.label}: ${this.iconValue}` : this.iconValue;
+	}
+	get triggerTitle() {
+		if (this.iconFace) return this.iconName;
+		let chosen = this.selectedOption;
+		return chosen?.meta ? `${chosen.label} ${chosen.meta}` : void 0;
+	}
+	valueId = `${guidFor(this)}-value`;
+	get iconLabelledBy() {
+		if (!this.iconFace || !this.args.labelledBy) return this.iconFace ? void 0 : this.args.labelledBy;
+		return `${this.args.labelledBy} ${this.valueId}`;
+	}
+	get placeholder() {
+		if (this.iconFace) return;
+		return this.args.placeholder ? this.args.placeholder : "Select…";
+	}
+	get options() {
+		return firstDefined(this.args.options, this.args.items) ?? [];
+	}
+	get disabled() {
+		return firstDefined(this.args.disabled, this.args.isDisabled);
+	}
+	get value() {
+		return this.args.value ?? this.internal;
+	}
+	get selectedOption() {
+		return this.options.find((o) => o.value === this.value);
+	}
+	choose = (option) => {
+		if (!option) return;
+		if (this.args.value === void 0) this.internal = option.value;
+		emit([this.args.onValueChange, this.args.onChange], option.value);
+	};
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "3DStQqcF",
+			"block": "[[[11,0],[24,0,\"pretui-selectwrap\"],[16,\"data-display\",[52,[30,0,[\"iconFace\"]],\"icon\"]],[24,\"data-test-pretui-select\",\"\"],[17,1],[24,\"data-scopedcss-ec1bbf807a-705972c842\",\"\"],[4,[32,0],[[30,2],[30,0,[\"explicitName\"]],[52,[30,0,[\"iconFace\"]],[30,0,[\"valueId\"]]]],null],[4,[30,0,[\"keepFocusInList\"]],null,null],[4,[30,0,[\"trackWrap\"]],null,null],[12],[1,\"\\n\"],[41,[30,0,[\"iconFace\"]],[[[1,\"    \"],[10,1],[15,1,[30,0,[\"valueId\"]]],[14,\"hidden\",\"\"],[14,\"data-scopedcss-ec1bbf807a-705972c842\",\"\"],[12],[1,[30,0,[\"iconValue\"]]],[13],[1,\"\\n\"]],[]],null],[1,\"  \"],[8,[32,1],[[24,0,\"pretui-selecttrigger\"],[16,\"title\",[30,0,[\"triggerTitle\"]]],[24,\"data-pretui-select-trigger\",\"\"],[24,\"data-test-pretui-select-trigger\",\"\"],[24,\"data-scopedcss-ec1bbf807a-705972c842\",\"\"]],[[\"@options\",\"@selected\",\"@onChange\",\"@placeholder\",\"@disabled\",\"@searchEnabled\",\"@searchField\",\"@beforeOptionsComponent\",\"@matchTriggerWidth\",\"@dropdownClass\",\"@renderInPlace\",\"@onOpen\",\"@ariaLabel\",\"@ariaLabelledBy\",\"@selectedItemComponent\"],[[30,0,[\"options\"]],[30,0,[\"selectedOption\"]],[30,0,[\"choose\"]],[30,0,[\"placeholder\"]],[30,0,[\"disabled\"]],[30,3],\"label\",[32,2],true,\"pretui-select-dropdown\",[30,0,[\"popupsInPlace\"]],[30,0,[\"matchListType\"]],[52,[30,0,[\"iconFace\"]],[30,0,[\"iconName\"]],[30,4]],[30,0,[\"iconLabelledBy\"]],[52,[30,0,[\"iconFace\"]],[50,[32,3],0,null,[[\"icon\"],[[30,0,[\"iconFace\"]]]]]]]],[[\"default\"],[[[[1,\"\\n    \"],[10,1],[14,\"data-test-pretui-select-option\",\"\"],[14,\"data-scopedcss-ec1bbf807a-705972c842\",\"\"],[12],[1,[30,5,[\"label\"]]],[13],[1,\"\\n\"],[41,[30,5,[\"meta\"]],[[[1,\"      \"],[10,1],[14,0,\"pretui-select-meta\"],[14,\"data-test-pretui-select-option-meta\",\"\"],[14,\"data-scopedcss-ec1bbf807a-705972c842\",\"\"],[12],[1,[30,5,[\"meta\"]]],[13],[1,\"\\n\"]],[]],null],[1,\"  \"]],[5]]]]],[1,\"\\n\"],[13],[1,\"\\n\"]],[\"&attrs\",\"@controlId\",\"@searchEnabled\",\"@label\",\"option\"],[\"if\",\"component\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/pretui/components/select.gts",
+			"scope": () => [
+				nameFromLabel,
+				PoweredSelect,
+				SelectSearch,
+				SelectIconFace
+			],
+			"isStrictMode": true
+		}), this);
+	}
+};
+//#endregion
+export { Select as t };

package/bundled-test-harness/assets/send-ai-assistant-message-test-CAn7M2dZ.js

@@ -0,0 +1,52 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Kn as APP_BOXEL_MESSAGE_MSGTYPE, Rr as testRealmInfo } from "./runtime-common-BTaLJEw-.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { n as RealmService } from "./realm-C_a9su1j.js";
+import { t as SendAiAssistantMessageTool } from "./send-ai-assistant-message-BJpusZZQ.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/tools/send-ai-assistant-message-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var StubRealmService = class extends RealmService {
+	get defaultReadableRealm() {
+		return {
+			path: testRealmURL,
+			info: testRealmInfo
+		};
+	}
+};
+(0, import_qunit.module)("Integration | tools | send-ai-assistant-message", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL]
+	});
+	let { createAndJoinRoom, getRoomEvents } = mockMatrixUtils;
+	hooks.beforeEach(function() {
+		getOwner(this).register("service:realm", StubRealmService);
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {}
+		}));
+	});
+	(0, import_qunit.test)("send an ai assistant message", async function(assert) {
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room-test"
+		});
+		await new SendAiAssistantMessageTool(getService("tool-service").toolContext).execute({
+			roomId,
+			prompt: "Hello, world!"
+		});
+		let message = getRoomEvents(roomId).pop();
+		assert.strictEqual(message.content.msgtype, APP_BOXEL_MESSAGE_MSGTYPE);
+		let boxelMessageData = JSON.parse(message.content.data);
+		assert.strictEqual(boxelMessageData.context.tools.length, 0);
+	});
+});
+//#endregion

package/bundled-test-harness/assets/send-bot-trigger-event-test-qBu5E_jy.js

@@ -0,0 +1,56 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Rr as testRealmInfo, h as isBotTriggerEvent } from "./runtime-common-BTaLJEw-.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { n as RealmService } from "./realm-C_a9su1j.js";
+import { t as SendBotTriggerEventTool } from "./send-bot-trigger-event-CmWePIBt.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/tools/send-bot-trigger-event-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var StubRealmService = class extends RealmService {
+	get defaultReadableRealm() {
+		return {
+			path: testRealmURL,
+			info: testRealmInfo
+		};
+	}
+};
+(0, import_qunit.module)("Integration | tools | send-bot-trigger-event", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL]
+	});
+	let { createAndJoinRoom, getRoomEvents } = mockMatrixUtils;
+	hooks.beforeEach(function() {
+		getOwner(this).register("service:realm", StubRealmService);
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {}
+		}));
+	});
+	(0, import_qunit.test)("sends a bot trigger event", async function(assert) {
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room-test"
+		});
+		await new SendBotTriggerEventTool(getService("tool-service").toolContext).execute({
+			roomId,
+			type: "pr-listing-create",
+			realm: testRealmURL,
+			input: { listingId: "catalog/listing-1" }
+		});
+		let event = getRoomEvents(roomId).pop();
+		assert.ok(isBotTriggerEvent(event));
+		assert.strictEqual(event.content.type, "pr-listing-create");
+		assert.strictEqual(event.content.realm, testRealmURL);
+		assert.strictEqual(event.content.userId, "@testuser:localhost");
+		assert.deepEqual(event.content.input, { listingId: "catalog/listing-1" });
+	});
+});
+//#endregion

package/bundled-test-harness/assets/send-request-via-proxy-test-CLuwLBq_.js

@@ -0,0 +1,380 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Rr as testRealmInfo } from "./runtime-common-BTaLJEw-.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { t as SendRequestViaProxyTool } from "./send-request-via-proxy-K12Pl05Y.js";
+import { n as RealmService } from "./realm-C_a9su1j.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, R as setupRealmServerEndpoints, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/tools/send-request-via-proxy-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var StubRealmService = class extends RealmService {
+	get defaultReadableRealm() {
+		return {
+			path: testRealmURL,
+			info: testRealmInfo
+		};
+	}
+};
+(0, import_qunit.module)("Integration | tools | send-request-via-proxy", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	setupRealmServerEndpoints(hooks, [{
+		route: "_request-forward",
+		getResponse: async (req) => {
+			const body = await req.json();
+			if (body.url.includes("/image")) {
+				const mockImageData = new Uint8Array([
+					137,
+					80,
+					78,
+					71,
+					13,
+					10,
+					26,
+					10
+				]);
+				return new Response(mockImageData, {
+					status: 200,
+					headers: { "Content-Type": "image/png" }
+				});
+			}
+			if (body.url.includes("/stream")) {
+				const mockStreamData = [
+					"data: {\"event\": \"start\", \"id\": \"123\"}\n\n",
+					"data: {\"event\": \"progress\", \"percent\": 50}\n\n",
+					"data: {\"event\": \"complete\", \"result\": \"success\"}\n\n",
+					"data: [DONE]\n\n"
+				].join("");
+				return new Response(mockStreamData, {
+					status: 200,
+					headers: { "Content-Type": "text/event-stream" }
+				});
+			}
+			if (body.url.includes("/error-400")) return new Response(JSON.stringify({
+				error: "Bad Request",
+				message: "Invalid parameters"
+			}), {
+				status: 400,
+				headers: { "Content-Type": "application/json" }
+			});
+			if (body.url.includes("/error-500")) return new Response(JSON.stringify({
+				error: "Internal Server Error",
+				message: "Something went wrong"
+			}), {
+				status: 500,
+				headers: { "Content-Type": "application/json" }
+			});
+			if (body.url.includes("/text")) return new Response("Hello, this is a text response!", {
+				status: 200,
+				headers: { "Content-Type": "text/plain" }
+			});
+			if (body.url.includes("/html")) return new Response("<html><body>HTML response</body></html>", {
+				status: 200,
+				headers: { "Content-Type": "text/html" }
+			});
+			if (body.url.includes("/xml")) return new Response("<xml><data>XML response</data></xml>", {
+				status: 200,
+				headers: { "Content-Type": "application/xml" }
+			});
+			if (body.url.includes("/large")) {
+				const largeData = { items: Array.from({ length: 1e3 }, (_, i) => ({
+					id: i,
+					data: "large item"
+				})) };
+				return new Response(JSON.stringify(largeData), {
+					status: 200,
+					headers: { "Content-Type": "application/json" }
+				});
+			}
+			if (body.url.includes("/realm-error")) return new Response("Internal Server Error", {
+				status: 500,
+				statusText: "Internal Server Error"
+			});
+			if (body.url.includes("/network-error")) throw new Error("Network error: Failed to fetch");
+			if (body.url.includes("/slow-error-body")) {
+				const stream = new ReadableStream({ async start(controller) {
+					await new Promise((resolve) => setTimeout(resolve, 300));
+					controller.enqueue(new TextEncoder().encode("upstream refused the request"));
+					controller.close();
+				} });
+				return new Response(stream, {
+					status: 502,
+					statusText: "Bad Gateway"
+				});
+			}
+			if (body.url.includes("/slow")) return new Promise((resolve, reject) => {
+				req.signal.addEventListener("abort", () => reject(new DOMException("The operation was aborted.", "AbortError")));
+				setTimeout(() => resolve(new Response(JSON.stringify({ answeredLate: true }), {
+					status: 200,
+					headers: { "Content-Type": "application/json" }
+				})), 2e3);
+			});
+			return new Response(JSON.stringify({
+				success: true,
+				data: {
+					id: 123,
+					name: "test"
+				},
+				method: body.method
+			}), {
+				status: 200,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+	}]);
+	hooks.beforeEach(function() {
+		getOwner(this).register("service:realm", StubRealmService);
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {}
+		}));
+	});
+	function createMockSendRequestViaProxyInput(overrides = {}) {
+		return {
+			url: "https://api.example.com/test",
+			method: "POST",
+			requestBody: JSON.stringify({ test: "data" }),
+			headers: { "Content-Type": "application/json" },
+			...overrides
+		};
+	}
+	(0, import_qunit.test)("successfully sends request and returns JSON response", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput();
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 200);
+		const responseData = await result.response.json();
+		assert.deepEqual(responseData, {
+			success: true,
+			data: {
+				id: 123,
+				name: "test"
+			},
+			method: "POST"
+		});
+	});
+	(0, import_qunit.test)("successfully sends request and returns text response", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({ url: "https://api.example.com/text" });
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 200);
+		const responseText = await result.response.text();
+		assert.strictEqual(responseText, "Hello, this is a text response!");
+	});
+	(0, import_qunit.test)("successfully sends request and returns image response", async function(assert) {
+		const mockImageData = new Uint8Array([
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		]);
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({
+			url: "https://api.example.com/image",
+			method: "GET",
+			requestBody: ""
+		});
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 200);
+		assert.strictEqual(result.response.headers.get("Content-Type"), "image/png");
+		const responseArrayBuffer = await result.response.arrayBuffer();
+		const responseData = new Uint8Array(responseArrayBuffer);
+		assert.deepEqual(responseData, mockImageData);
+	});
+	(0, import_qunit.test)("successfully sends request and returns event stream response", async function(assert) {
+		const mockStreamData = [
+			"data: {\"event\": \"start\", \"id\": \"123\"}\n\n",
+			"data: {\"event\": \"progress\", \"percent\": 50}\n\n",
+			"data: {\"event\": \"complete\", \"result\": \"success\"}\n\n",
+			"data: [DONE]\n\n"
+		].join("");
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({
+			url: "https://api.example.com/stream",
+			stream: true
+		});
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 200);
+		assert.strictEqual(result.response.headers.get("Content-Type"), "text/event-stream");
+		const responseText = await result.response.text();
+		assert.strictEqual(responseText, mockStreamData);
+	});
+	(0, import_qunit.test)("handles 4xx error responses from external API", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({ url: "https://api.example.com/error-400" });
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 500);
+		const responseData = await result.response.json();
+		assert.ok(responseData.error, "Should have error field");
+		assert.ok(responseData.details, "Should have details field");
+		assert.ok(responseData.error.includes("Request forward failed: 400"), "Error should mention the original 400 status");
+	});
+	(0, import_qunit.test)("handles 5xx error responses from external API", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({ url: "https://api.example.com/error-500" });
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 500);
+		const responseData = await result.response.json();
+		assert.ok(responseData.error, "Should have error field");
+		assert.ok(responseData.details, "Should have details field");
+		assert.ok(responseData.error.includes("Request forward failed: 500"), "Error should mention the original 500 status");
+	});
+	(0, import_qunit.test)("handles realm server errors gracefully", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({ url: "https://api.example.com/realm-error" });
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 500);
+		const responseData = await result.response.json();
+		assert.ok(responseData.error, "Should have error field");
+		assert.ok(responseData.details, "Should have details field");
+	});
+	(0, import_qunit.test)("handles network errors gracefully", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({ url: "https://api.example.com/network-error" });
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 500);
+		const responseData = await result.response.json();
+		assert.ok(responseData.error, "Should have error field");
+		assert.ok(responseData.details, "Should have details field");
+	});
+	(0, import_qunit.test)("supports different HTTP methods", async function(assert) {
+		for (const method of [
+			"GET",
+			"POST",
+			"PUT",
+			"PATCH",
+			"DELETE"
+		]) {
+			const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+			const input = createMockSendRequestViaProxyInput({ method });
+			const result = await requestForwardCommand.execute(input);
+			assert.ok(result, `Command should return a result for ${method}`);
+			assert.strictEqual(result.response.status, 200);
+			const responseData = await result.response.json();
+			assert.strictEqual(responseData.method, method);
+		}
+	});
+	(0, import_qunit.test)("handles different content types in response", async function(assert) {
+		for (const testCase of [
+			{
+				url: "https://api.example.com/test",
+				contentType: "application/json"
+			},
+			{
+				url: "https://api.example.com/text",
+				contentType: "text/plain"
+			},
+			{
+				url: "https://api.example.com/html",
+				contentType: "text/html"
+			},
+			{
+				url: "https://api.example.com/xml",
+				contentType: "application/xml"
+			}
+		]) {
+			const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+			const input = createMockSendRequestViaProxyInput({ url: testCase.url });
+			const result = await requestForwardCommand.execute(input);
+			assert.ok(result, `Command should return a result for ${testCase.contentType}`);
+			assert.strictEqual(result.response.status, 200);
+			assert.strictEqual(result.response.headers.get("Content-Type"), testCase.contentType);
+		}
+	});
+	(0, import_qunit.test)("handles large response data", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({ url: "https://api.example.com/large" });
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 200);
+		const responseData = await result.response.json();
+		assert.strictEqual(responseData.items.length, 1e3);
+		assert.strictEqual(responseData.items[0].id, 0);
+		assert.strictEqual(responseData.items[999].id, 999);
+	});
+	(0, import_qunit.test)("handles special characters in URL and headers", async function(assert) {
+		const specialUrl = "https://api.example.com/test?param=value&special=test%20with%20spaces";
+		const specialHeaders = {
+			"X-Custom-Header": "header with spaces and special chars: !@#$%^&*()",
+			Authorization: "Bearer token-with-special-chars: !@#$%^&*()"
+		};
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({
+			url: specialUrl,
+			headers: specialHeaders
+		});
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 200);
+	});
+	(0, import_qunit.test)("handles empty request body", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({
+			method: "GET",
+			requestBody: ""
+		});
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 200);
+	});
+	(0, import_qunit.test)("handles null/undefined headers", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({ headers: void 0 });
+		const result = await requestForwardCommand.execute(input);
+		assert.ok(result, "Command should return a result");
+		assert.strictEqual(result.response.status, 200);
+	});
+	(0, import_qunit.test)("timeoutMs cancels the request rather than only abandoning the wait", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({
+			url: "https://api.example.com/slow",
+			timeoutMs: 50
+		});
+		const result = await requestForwardCommand.execute(input);
+		assert.strictEqual(result.response.status, 500, "the caller gets an error rather than the late answer");
+		const responseData = await result.response.json();
+		assert.true(String(responseData.error).includes("timed out after 50ms"), "the error names the budget that was exceeded");
+	});
+	(0, import_qunit.test)("a budget that elapses while reading an answered response is not a timeout", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({
+			url: "https://api.example.com/slow-error-body",
+			timeoutMs: 150
+		});
+		const responseData = await (await requestForwardCommand.execute(input)).response.json();
+		const message = String(responseData.error);
+		assert.false(message.includes("timed out"), `an answered request is not reported as a timeout (got: ${message})`);
+		assert.true(message.includes("502"), `the status the server actually returned survives (got: ${message})`);
+		assert.true(message.includes("upstream refused the request"), `the body the server actually returned survives (got: ${message})`);
+	});
+	(0, import_qunit.test)("a request without a timeoutMs waits as long as it takes", async function(assert) {
+		const requestForwardCommand = new SendRequestViaProxyTool(getService("tool-service").toolContext);
+		const input = createMockSendRequestViaProxyInput({ url: "https://api.example.com/slow" });
+		const result = await requestForwardCommand.execute(input);
+		assert.strictEqual(result.response.status, 200, "no deadline means no cancellation");
+		const responseData = await result.response.json();
+		assert.true(responseData.answeredLate, "the late answer is delivered");
+	});
+});
+//#endregion