gentle-pi 3.3.0 → 3.5.0

package/tests/ask-user-choice.test.ts

@@ -133,6 +133,47 @@ const options = [
 	{ label: "Preserve requested hash", description: "Keep the hash from the original request.", value: "preserve_requested_hash" },
 ];
 
+const INTERACTIVE_HOST_ENV = "GENTLE_SHELL_INTERACTIVE_HOST";
+
+function withInteractiveHostEnv(t: { after(fn: () => void): void }): void {
+	const previous = process.env[INTERACTIVE_HOST_ENV];
+	process.env[INTERACTIVE_HOST_ENV] = "1";
+	t.after(() => {
+		if (previous === undefined) delete process.env[INTERACTIVE_HOST_ENV];
+		else process.env[INTERACTIVE_HOST_ENV] = previous;
+	});
+}
+
+/** Fake interactive-RPC-host ctx: scripted `select`/`input` answers, one per call. */
+function rpcHostContext(selectAnswers: readonly (string | undefined)[], inputAnswers: readonly (string | undefined)[] = []) {
+	const selectCalls: Array<{ title: string; options: string[] }> = [];
+	const inputCalls: Array<{ title: string; placeholder?: string }> = [];
+	let selectIndex = 0;
+	let inputIndex = 0;
+	return {
+		ctx: {
+			mode: "rpc",
+			hasUI: true,
+			ui: {
+				select: async (title: string, opts: string[]) => {
+					selectCalls.push({ title, options: opts });
+					const answer = selectAnswers[selectIndex];
+					selectIndex += 1;
+					return answer;
+				},
+				input: async (title: string, placeholder?: string) => {
+					inputCalls.push({ title, placeholder });
+					const answer = inputAnswers[inputIndex];
+					inputIndex += 1;
+					return answer;
+				},
+			},
+		},
+		selectCalls,
+		inputCalls,
+	};
+}
+
 function tuiContext(inputs: readonly string[], rendered: { value: string }) {
 	return {
 		mode: "tui",
@@ -483,6 +524,80 @@ test("ask_user_choice cancels without a value and remains unavailable outside th
 	);
 });
 
+test("ask_user_choice stays unavailable on a plain rpc host without the interactive-host variable", async (t) => {
+	const { tool } = registerChoiceTool();
+	t.after(() => { delete process.env[INTERACTIVE_HOST_ENV]; });
+	delete process.env[INTERACTIVE_HOST_ENV];
+
+	await assert.rejects(
+		() => tool.execute("call", { question: "Proceed?", options }, new AbortController().signal, undefined, { mode: "rpc", hasUI: true, ui: { select: async () => undefined } }),
+		/unavailable outside the interactive TUI/,
+	);
+});
+
+/** Expected `gentle-pi:ask-user-choice:blocked` sequence around one RPC-dialog turn. */
+const RPC_BLOCKED_SEQUENCE = [
+	{ channel: "gentle-pi:ask-user-choice:blocked", data: { active: true } },
+	{ channel: "gentle-pi:ask-user-choice:blocked", data: { active: false } },
+];
+
+test("ask_user_choice resolves a selection through RPC dialogs on an interactive host", async (t) => {
+	withInteractiveHostEnv(t);
+	const registration = registerChoiceTool();
+	const { tool } = registration;
+	const { ctx, selectCalls } = rpcHostContext([options[1]!.label]);
+
+	const result = await tool.execute("call", { question: "Proceed?", options }, new AbortController().signal, undefined, ctx);
+
+	assert.equal(selectCalls.length, 1);
+	assert.equal(selectCalls[0]?.title, "Proceed?");
+	assert.deepEqual(selectCalls[0]?.options, [options[0]!.label, options[1]!.label]);
+	assert.deepEqual(result.details.selection, { value: options[1]!.value, label: options[1]!.label, index: 2 });
+	assert.equal(result.content[0]?.text, `User selected: 2. ${options[1]!.label} (value: ${options[1]!.value})`);
+	assert.deepEqual(registration.emittedEvents(), RPC_BLOCKED_SEQUENCE);
+});
+
+test("ask_user_choice resolves an Other… custom response through ctx.ui.input on an interactive host", async (t) => {
+	withInteractiveHostEnv(t);
+	const registration = registerChoiceTool();
+	const { tool } = registration;
+	const { ctx, selectCalls, inputCalls } = rpcHostContext(["Other…"], ["a free-form reply"]);
+
+	const result = await tool.execute("call", { question: "Explain?", options, allowCustomResponse: true }, new AbortController().signal, undefined, ctx);
+
+	assert.deepEqual(selectCalls[0]?.options, [options[0]!.label, options[1]!.label, "Other…"]);
+	assert.equal(inputCalls.length, 1);
+	assert.equal(inputCalls[0]?.title, "Explain?");
+	assert.deepEqual(result.details, { question: "Explain?", options, customResponse: "a free-form reply" });
+	assert.equal(result.content[0]?.text, "User responded: a free-form reply");
+	assert.deepEqual(registration.emittedEvents(), RPC_BLOCKED_SEQUENCE);
+});
+
+test("ask_user_choice cancels through RPC dialogs like the TUI path when select returns undefined", async (t) => {
+	withInteractiveHostEnv(t);
+	const registration = registerChoiceTool();
+	const { tool } = registration;
+	const { ctx } = rpcHostContext([undefined]);
+
+	const result = await tool.execute("call", { question: "Proceed?", options }, new AbortController().signal, undefined, ctx);
+
+	assert.deepEqual(result.details, { question: "Proceed?", options, cancelled: true });
+	assert.equal(result.content[0]?.text, "User cancelled the choice");
+	assert.deepEqual(registration.emittedEvents(), RPC_BLOCKED_SEQUENCE, "the blocked lifecycle must still balance on a cancel");
+});
+
+test("ask_user_choice cancels through RPC dialogs when the Other… input is cancelled", async (t) => {
+	withInteractiveHostEnv(t);
+	const registration = registerChoiceTool();
+	const { tool } = registration;
+	const { ctx } = rpcHostContext(["Other…"], [undefined]);
+
+	const result = await tool.execute("call", { question: "Explain?", options, allowCustomResponse: true }, new AbortController().signal, undefined, ctx);
+
+	assert.deepEqual(result.details, { question: "Explain?", options, cancelled: true });
+	assert.deepEqual(registration.emittedEvents(), RPC_BLOCKED_SEQUENCE, "the blocked lifecycle must still balance on a cancel");
+});
+
 test("ask_user_choice emits a private balanced lifecycle around selection and cancellation", async () => {
 	const sequence: string[] = [];
 	const selectedRegistration = registerChoiceTool([], ({ data }) => {
@@ -582,3 +697,17 @@ test("ask_user_choice is offered only for interactive TUI turns and preserves th
 	for (const hook of registration.hooks) await hook({}, { mode: "print" });
 	assert.deepEqual(registration.activeTools(), ["read", "ask_user_question"]);
 });
+
+test("ask_user_choice is offered on an interactive rpc host and withdrawn once the variable is gone", async (t) => {
+	const registration = registerChoiceTool(["read"]);
+	registration.allowRuntimeActions();
+	t.after(() => { delete process.env[INTERACTIVE_HOST_ENV]; });
+
+	process.env[INTERACTIVE_HOST_ENV] = "1";
+	for (const hook of registration.hooks) await hook({}, { mode: "rpc" });
+	assert.deepEqual(registration.activeTools(), ["read", "ask_user_choice"]);
+
+	delete process.env[INTERACTIVE_HOST_ENV];
+	for (const hook of registration.hooks) await hook({}, { mode: "rpc" });
+	assert.deepEqual(registration.activeTools(), ["read"]);
+});