@geoqiao/pi-ask 1.2.0 → 1.2.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.2.1](https://github.com/geoqiao/pi-ask/compare/v1.2.0...v1.2.1) (2026-08-16)
+
+
+### Bug Fixes
+
+* harden RPC fallback interactions ([4cceb3b](https://github.com/geoqiao/pi-ask/commit/4cceb3b2ab8d19b46f4688a53f8b7ae52e2b06ae))
+
 # [1.2.0](https://github.com/geoqiao/pi-ask/compare/v1.1.0...v1.2.0) (2026-08-16)
 
 

package/README.md

@@ -3,6 +3,7 @@
 # @geoqiao/pi-ask
 
 [![npm downloads](https://badgen.net/npm/dm/@geoqiao/pi-ask)](https://www.npmjs.com/package/@geoqiao/pi-ask)
+[![CI](https://github.com/geoqiao/pi-ask/actions/workflows/ci.yml/badge.svg)](https://github.com/geoqiao/pi-ask/actions/workflows/ci.yml)
 [![last commit](https://badgen.net/github/last-commit/geoqiao/pi-ask)](https://github.com/geoqiao/pi-ask/commits/main)
 [![stars](https://badgen.net/github/stars/geoqiao/pi-ask)](https://github.com/geoqiao/pi-ask/stargazers)
 
@@ -206,6 +207,8 @@ When Pi runs in RPC mode with portable extension UI support, `ask_user` keeps th
 - multi-select repeats `select` with `[ ]` / `[x]` markers until `Finish selection` is chosen
 - descriptions and preview content are flattened into readable option strings
 - multiple questions include `[current/total]` progress in each dialog title
+- dismissing a question or notes-menu `select` cancels the flow, while dismissing a nested answer/note editor returns to its parent dialog
+- tool abort signals close portable `select`/`input` dialogs; Pi's portable `editor` cannot be interrupted until it resolves
 
 RPC intentionally does not reproduce the tabbed same-screen form, native checkbox cards, custom preview pane, question-type hotkeys, settings overlay, or final Submit/Elaborate review tab. The fallback completes in `submit` mode after the sequential questions. `/answer`, `/answer:again`, `/ask:replay`, and `/ask-settings` remain TUI-only.
 

package/docs/contract.md

@@ -160,7 +160,7 @@ This document defines the stable external behavior. It does not explain internal
 
 ## Output rules
 
-- `cancelled: true` means the user dismissed the flow, UI was unavailable, or the payload was invalid before UI opened
+- `cancelled: true` means the user dismissed a flow-level selection, chose Cancel, aborted the flow, UI was unavailable, or the payload was invalid before UI opened
 - invalid payloads return `error.kind === "invalid_input"` with structured `issues` and a transcript-friendly `Invalid ask_user payload:` message
 - `mode: "submit"` is normal completion; `mode: "elaborate"` means the user asked the agent to continue with follow-up clarification based on notes
 - unanswered questions are omitted from `answers`
@@ -175,7 +175,7 @@ This document defines the stable external behavior. It does not explain internal
 - `customText` stores the free-form answer
 - on single-select questions, saving free-form text clears selected options for that question
 - on multi-select questions, `values` and `labels` include both selected options and `customText` when both are present
-- on multi-select questions, selected options keep their original order and `customText` is appended last
+- on multi-select questions, selected options keep the user's selection order and `customText` is appended last
 - submitting free-form text on a multi-select question stays on the same question tab and marks the custom row selected
 - on multi-select questions, toggling an empty custom row opens the free-form editor, while toggling a custom row with saved free-form text selects or deselects it without opening the editor or clearing the text
 - saving or clearing free-form text on a multi-select question does not clear other selected options
@@ -263,10 +263,12 @@ The rich ask flow uses `ctx.ui.custom()` only in TUI mode. RPC mode never calls
 - short and multiline custom answers use `input` and `editor`
 - every question exposes Skip explicitly; required remains advisory and its Skip label says so
 - after each question, a portable action dialog can add/edit a short or multiline question note, or an editor note for a selected option
-- multi-select repeatedly calls `select`, showing `[ ]` / `[x]` option markers and a `Finish selection` action; selections are collected locally in original option order
+- multi-select repeatedly calls `select`, showing `[ ]` / `[x]` option markers and a `Finish selection` action; selections are collected locally in the user's selection order
 - descriptions and preview content are flattened into option strings instead of using a custom preview pane
 - multiple questions are sequential and every title includes `[current/total]` progress
-- dismissing a value dialog or choosing Cancel returns `cancelled: true`
+- dismissing a question or optional-notes action `select`, choosing Cancel, or aborting the tool returns `cancelled: true`
+- dismissing a nested custom-answer or note `input`/`editor` abandons that edit and returns to its parent action dialog without changing the answer
+- `select` and `input` observe the tool abort signal; Pi's portable `editor` API has no signal or timeout option, so an abort is observed only after an open editor resolves
 
 RPC does not provide the tabbed same-screen form, native checkbox cards, custom preview pane, question-type hotkeys, settings overlay, or final Submit/Elaborate review tab. RPC completion uses `mode: "submit"`. `/answer`, `/answer:again`, `/ask:replay`, and `/ask-settings` remain TUI-only.
 

package/docs/remote-events.md

@@ -18,7 +18,7 @@ Remote submit:
 
 ## Started
 
-Emitted after a validated ask UI flow opens.
+Emitted after a validated TUI ask flow opens. The RPC portable-dialog fallback does not start the remote event bridge or emit lifecycle events.
 
 ```ts
 type PiAskStartedEvent = {
@@ -104,7 +104,7 @@ Correlate by `requestId` and `flowId`. Do not depend on strict ordering between
 
 ## Completed
 
-Emitted when the flow resolves.
+Emitted when the TUI flow resolves. RPC portable-dialog completion is returned through the normal tool result instead.
 
 ```ts
 type PiAskCompletedEvent = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geoqiao/pi-ask",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Pi package that adds an interactive ask_user clarification tool.",
   "license": "MIT",
   "type": "module",

package/src/ask-tool.ts

@@ -51,7 +51,7 @@ async function executeAskTool(
 	pi: Pick<ExtensionAPI, "appendEntry">,
 	toolCallId: string,
 	params: AskParams,
-	_signal: AbortSignal | undefined,
+	signal: AbortSignal | undefined,
 	_onUpdate: unknown,
 	ctx: ExtensionContext,
 	remoteAsk?: RemoteAskRuntime
@@ -70,7 +70,9 @@ async function executeAskTool(
 	});
 	if (ctx.mode !== "tui") {
 		if (ctx.mode === "rpc" && ctx.hasUI) {
-			return successfulResponse(await runRpcAskFlow(ctx, validation.state));
+			return successfulResponse(
+				await runRpcAskFlow(ctx, validation.state, { signal })
+			);
 		}
 		return nonInteractiveResponse(validation.state);
 	}

package/src/rpc/controller.ts

@@ -20,11 +20,21 @@ import type {
 
 type RpcUi = Pick<ExtensionContext["ui"], "editor" | "input" | "select">;
 
-interface RpcStepResult {
-	cancelled: boolean;
-	state: AskState;
+interface RpcFlowOptions {
+	signal?: AbortSignal;
 }
 
+type RpcCompletionResult =
+	| { kind: "cancelled"; state: AskState }
+	| { kind: "completed"; state: AskState };
+
+type RpcActionResult = RpcCompletionResult | { kind: "back"; state: AskState };
+
+type RpcEditResult =
+	| { kind: "back"; state: AskState }
+	| { kind: "cancelled"; state: AskState }
+	| { kind: "saved"; state: AskState };
+
 interface SelectAction {
 	kind:
 		| "cancel"
@@ -56,23 +66,40 @@ const FINISH_SELECTION_LABEL = "Finish selection";
 
 export async function runRpcAskFlow(
 	ctx: { ui: RpcUi },
-	initialState: AskState
+	initialState: AskState,
+	options: RpcFlowOptions = {}
 ): Promise<AskResult> {
 	let state = initialState;
 
 	for (const [questionIndex] of state.questions.entries()) {
-		const answerStep = await askQuestion(ctx.ui, state, questionIndex);
+		if (options.signal?.aborted) {
+			return cancelledResult(state);
+		}
+		const answerStep = await askQuestion(
+			ctx.ui,
+			state,
+			questionIndex,
+			options.signal
+		);
 		state = answerStep.state;
-		if (answerStep.cancelled) {
+		if (answerStep.kind === "cancelled") {
 			return cancelledResult(state);
 		}
 
-		const noteStep = await askForOptionalNotes(ctx.ui, state, questionIndex);
+		const noteStep = await askForOptionalNotes(
+			ctx.ui,
+			state,
+			questionIndex,
+			options.signal
+		);
 		state = noteStep.state;
-		if (noteStep.cancelled) {
+		if (noteStep.kind === "cancelled") {
 			return cancelledResult(state);
 		}
 	}
+	if (options.signal?.aborted) {
+		return cancelledResult(state);
+	}
 
 	return toAskResult({
 		...state,
@@ -84,72 +111,94 @@ export async function runRpcAskFlow(
 async function askQuestion(
 	ui: RpcUi,
 	state: AskState,
-	questionIndex: number
-): Promise<RpcStepResult> {
+	questionIndex: number,
+	signal?: AbortSignal
+): Promise<RpcCompletionResult> {
 	const question = state.questions[questionIndex];
 	if (!question) {
-		return { cancelled: false, state };
+		return { kind: "completed", state };
 	}
 	if (question.type === "multi") {
-		return await askMultiQuestion(ui, state, question, questionIndex);
+		return await askMultiQuestion(ui, state, question, questionIndex, signal);
 	}
-	return await askSingleQuestion(ui, state, question, questionIndex);
+	return await askSingleQuestion(ui, state, question, questionIndex, signal);
 }
 
 async function askSingleQuestion(
 	ui: RpcUi,
-	state: AskState,
+	initialState: AskState,
 	question: AskQuestion,
-	questionIndex: number
-): Promise<RpcStepResult> {
-	const actions: SelectAction[] = question.options
-		.filter((option) => !option.freeform)
-		.map((option, optionIndex) => ({
-			kind: "option" as const,
-			label: formatOption(option, optionIndex),
-			optionIndex,
-		}));
-	appendCommonActions(actions, question);
+	questionIndex: number,
+	signal?: AbortSignal
+): Promise<RpcCompletionResult> {
+	let state = initialState;
+	while (true) {
+		if (signal?.aborted) {
+			return { kind: "cancelled", state };
+		}
+		const actions: SelectAction[] = [...question.options.entries()]
+			.filter(([, option]) => !option.freeform)
+			.map(([optionIndex, option]) => ({
+				kind: "option" as const,
+				label: formatOption(option, optionIndex),
+				optionIndex,
+			}));
+		appendCommonActions(actions, question);
 
-	const action = await selectAction(
-		ui,
-		formatTitle(state, question, questionIndex),
-		actions
-	);
-	return applySingleAction({
-		action,
-		question,
-		questionIndex,
-		state,
-		ui,
-	});
+		const action = await selectAction(
+			ui,
+			formatTitle(state, question, questionIndex),
+			actions,
+			signal
+		);
+		const result = await applySingleAction({
+			action,
+			question,
+			questionIndex,
+			signal,
+			state,
+			ui,
+		});
+		if (result.kind !== "back") {
+			return result;
+		}
+		state = result.state;
+	}
 }
 
 async function applySingleAction(args: {
 	action: SelectAction | undefined;
 	question: AskQuestion;
 	questionIndex: number;
+	signal?: AbortSignal;
 	state: AskState;
 	ui: RpcUi;
-}): Promise<RpcStepResult> {
-	const { action, question, questionIndex, state, ui } = args;
+}): Promise<RpcActionResult> {
+	const { action, question, questionIndex, signal, state, ui } = args;
 	if (!action || action.kind === "cancel") {
-		return { cancelled: true, state };
+		return { kind: "cancelled", state };
 	}
 	if (action.kind === "skip") {
-		return { cancelled: false, state: clearAnswer(state, question.id) };
+		return {
+			kind: "completed",
+			state: clearAnswer(state, question.id),
+		};
 	}
 	if (action.kind === "custom-input" || action.kind === "custom-editor") {
-		return await askForCustomAnswer(
+		const editResult = await askForCustomAnswer(
 			ui,
 			state,
 			question,
 			questionIndex,
-			action.kind === "custom-editor"
+			action.kind === "custom-editor",
+			signal
 		);
+		return editResult.kind === "saved"
+			? { kind: "completed", state: editResult.state }
+			: editResult;
 	}
 	if (action.kind !== "option") {
-		return { cancelled: true, state };
+		return { kind: "cancelled", state };
 	}
 
 	return selectSingleOption(state, question, action.optionIndex);
@@ -159,14 +208,14 @@ function selectSingleOption(
 	state: AskState,
 	question: AskQuestion,
 	optionIndex: number | undefined
-): RpcStepResult {
+): RpcCompletionResult {
 	const option =
 		optionIndex === undefined ? undefined : question.options[optionIndex];
 	if (!option || optionIndex === undefined) {
-		return { cancelled: true, state };
+		return { kind: "cancelled", state };
 	}
 	return {
-		cancelled: false,
+		kind: "completed",
 		state: updateAnswer(state, question.id, (answer) =>
 			setSingleSelection(answer, option, optionIndex)
 		),
@@ -177,25 +226,31 @@ async function askMultiQuestion(
 	ui: RpcUi,
 	initialState: AskState,
 	question: AskQuestion,
-	questionIndex: number
-): Promise<RpcStepResult> {
+	questionIndex: number,
+	signal?: AbortSignal
+): Promise<RpcCompletionResult> {
 	let state = initialState;
 	while (true) {
+		if (signal?.aborted) {
+			return { kind: "cancelled", state };
+		}
 		const actions = createMultiActions(question, state.answers[question.id]);
 		const action = await selectAction(
 			ui,
 			formatTitle(state, question, questionIndex, "Select all that apply"),
-			actions
+			actions,
+			signal
 		);
 		const actionResult = await applyMultiAction({
 			action,
 			question,
 			questionIndex,
+			signal,
 			state,
 			ui,
 		});
-		if (actionResult.done) {
-			return actionResult.step;
+		if (actionResult.kind !== "back") {
+			return actionResult;
 		}
 		state = actionResult.state;
 	}
@@ -205,9 +260,9 @@ function createMultiActions(
 	question: AskQuestion,
 	answer: AskStateAnswer | undefined
 ): SelectAction[] {
-	const actions: SelectAction[] = question.options
-		.filter((option) => !option.freeform)
-		.map((option, optionIndex) => ({
+	const actions: SelectAction[] = [...question.options.entries()]
+		.filter(([, option]) => !option.freeform)
+		.map(([optionIndex, option]) => ({
 			kind: "option" as const,
 			label: formatOption(option, optionIndex, {
 				selected: isOptionSelected(answer, option.value),
@@ -228,41 +283,39 @@ function createMultiActions(
 	return actions;
 }
 
-type MultiActionResult =
-	| { done: false; state: AskState }
-	| { done: true; step: RpcStepResult };
-
 async function applyMultiAction(args: {
 	action: SelectAction | undefined;
 	question: AskQuestion;
 	questionIndex: number;
+	signal?: AbortSignal;
 	state: AskState;
 	ui: RpcUi;
-}): Promise<MultiActionResult> {
-	const { action, question, questionIndex, state, ui } = args;
+}): Promise<RpcActionResult> {
+	const { action, question, questionIndex, signal, state, ui } = args;
 	if (!action || action.kind === "cancel") {
-		return { done: true, step: { cancelled: true, state } };
+		return { kind: "cancelled", state };
 	}
 	if (action.kind === "finish") {
-		return { done: true, step: { cancelled: false, state } };
+		return { kind: "completed", state };
 	}
 	if (action.kind === "skip") {
 		return {
-			done: true,
-			step: { cancelled: false, state: clearAnswer(state, question.id) },
+			kind: "completed",
+			state: clearAnswer(state, question.id),
 		};
 	}
 	if (action.kind === "custom-input" || action.kind === "custom-editor") {
-		const step = await askForCustomAnswer(
+		const editResult = await askForCustomAnswer(
 			ui,
 			state,
 			question,
 			questionIndex,
-			action.kind === "custom-editor"
+			action.kind === "custom-editor",
+			signal
 		);
-		return step.cancelled
-			? { done: true, step }
-			: { done: false, state: step.state };
+		return editResult.kind === "cancelled"
+			? editResult
+			: { kind: "back", state: editResult.state };
 	}
 	return applyMultiOptionAction(state, question, action);
 }
@@ -271,24 +324,18 @@ function applyMultiOptionAction(
 	state: AskState,
 	question: AskQuestion,
 	action: SelectAction
-): MultiActionResult {
+): RpcActionResult {
 	const optionIndex = action.optionIndex;
 	const option =
 		optionIndex === undefined ? undefined : question.options[optionIndex];
 	if (!option || optionIndex === undefined) {
-		return { done: true, step: { cancelled: true, state } };
+		return { kind: "cancelled", state };
 	}
 	return {
-		done: false,
-		state: updateAnswer(state, question.id, (currentAnswer) => {
-			const nextAnswer = toggleSelection(currentAnswer, option, optionIndex);
-			return {
-				...nextAnswer,
-				selected: [...nextAnswer.selected].sort(
-					(left, right) => left.index - right.index
-				),
-			};
-		}),
+		kind: "back",
+		state: updateAnswer(state, question.id, (currentAnswer) =>
+			toggleSelection(currentAnswer, option, optionIndex)
+		),
 	};
 }
 
@@ -297,8 +344,12 @@ async function askForCustomAnswer(
 	state: AskState,
 	question: AskQuestion,
 	questionIndex: number,
-	multiline: boolean
-): Promise<RpcStepResult> {
+	multiline: boolean,
+	signal?: AbortSignal
+): Promise<RpcEditResult> {
+	if (signal?.aborted) {
+		return { kind: "cancelled", state };
+	}
 	const currentText = state.answers[question.id]?.customText;
 	const title = formatTitle(
 		state,
@@ -308,13 +359,16 @@ async function askForCustomAnswer(
 	);
 	const value = multiline
 		? await ui.editor(title, currentText ?? "")
-		: await ui.input(title, formatInputPlaceholder(currentText));
+		: await ui.input(title, formatInputPlaceholder(currentText), { signal });
+	if (signal?.aborted) {
+		return { kind: "cancelled", state };
+	}
 	if (value === undefined) {
-		return { cancelled: true, state };
+		return { kind: "back", state };
 	}
 
 	return {
-		cancelled: false,
+		kind: "saved",
 		state: updateAnswer(state, question.id, (answer) =>
 			saveCustomText(
 				answer,
@@ -328,31 +382,37 @@ async function askForCustomAnswer(
 async function askForOptionalNotes(
 	ui: RpcUi,
 	initialState: AskState,
-	questionIndex: number
-): Promise<RpcStepResult> {
+	questionIndex: number,
+	signal?: AbortSignal
+): Promise<RpcCompletionResult> {
 	let state = initialState;
 	const question = state.questions[questionIndex];
 	if (!question) {
-		return { cancelled: false, state };
+		return { kind: "completed", state };
 	}
 
 	while (true) {
+		if (signal?.aborted) {
+			return { kind: "cancelled", state };
+		}
 		const answer = state.answers[question.id];
 		const actions = createNoteActions(answer);
 		const action = await selectNoteAction(
 			ui,
 			formatTitle(state, question, questionIndex, "Optional notes"),
-			actions
+			actions,
+			signal
 		);
 		const actionResult = await applyNoteAction({
 			action,
 			question,
 			questionIndex,
+			signal,
 			state,
 			ui,
 		});
-		if (actionResult.done) {
-			return actionResult.step;
+		if (actionResult.kind !== "back") {
+			return actionResult;
 		}
 		state = actionResult.state;
 	}
@@ -387,38 +447,47 @@ function createNoteActions(answer: AskStateAnswer | undefined): NoteAction[] {
 			kind: "option-note" as const,
 			optionValue: selection.value,
 			label: answer?.optionNotes?.[selection.value]
-				? `Edit note for selected option: ${compactText(selection.label)}…`
-				: `Add note for selected option: ${compactText(selection.label)}…`,
+				? `Edit note for selected option: ${selection.index}. ${compactText(selection.label)}…`
+				: `Add note for selected option: ${selection.index}. ${compactText(selection.label)}…`,
 		})),
 		{ kind: "cancel", label: CANCEL_LABEL },
 	];
 }
 
-type NoteActionResult =
-	| { done: false; state: AskState }
-	| { done: true; step: RpcStepResult };
-
 async function applyNoteAction(args: {
 	action: NoteAction | undefined;
 	question: AskQuestion;
 	questionIndex: number;
+	signal?: AbortSignal;
 	state: AskState;
 	ui: RpcUi;
-}): Promise<NoteActionResult> {
-	const { action, question, questionIndex, state, ui } = args;
+}): Promise<RpcActionResult> {
+	const { action, question, questionIndex, signal, state, ui } = args;
 	if (!action || action.kind === "cancel") {
-		return { done: true, step: { cancelled: true, state } };
+		return { kind: "cancelled", state };
 	}
 	if (action.kind === "continue") {
-		return { done: true, step: { cancelled: false, state } };
+		return { kind: "completed", state };
 	}
 	if (action.kind === "question-input") {
-		return await editQuestionNote(ui, state, question, questionIndex, false);
+		return noteEditActionResult(
+			await editQuestionNote(ui, state, question, questionIndex, false, signal)
+		);
 	}
 	if (action.kind === "question-editor") {
-		return await editQuestionNote(ui, state, question, questionIndex, true);
+		return noteEditActionResult(
+			await editQuestionNote(ui, state, question, questionIndex, true, signal)
+		);
 	}
-	return await editOptionNote(ui, state, question, questionIndex, action);
+	return noteEditActionResult(
+		await editOptionNote(ui, state, question, questionIndex, action, signal)
+	);
+}
+
+function noteEditActionResult(result: RpcEditResult): RpcActionResult {
+	return result.kind === "cancelled"
+		? result
+		: { kind: "back", state: result.state };
 }
 
 async function editQuestionNote(
@@ -426,18 +495,25 @@ async function editQuestionNote(
 	state: AskState,
 	question: AskQuestion,
 	questionIndex: number,
-	multiline: boolean
-): Promise<NoteActionResult> {
+	multiline: boolean,
+	signal?: AbortSignal
+): Promise<RpcEditResult> {
+	if (signal?.aborted) {
+		return { kind: "cancelled", state };
+	}
 	const currentNote = state.answers[question.id]?.note;
 	const title = formatTitle(state, question, questionIndex, "Question note");
 	const value = multiline
 		? await ui.editor(title, currentNote ?? "")
-		: await ui.input(title, formatNotePlaceholder(currentNote));
+		: await ui.input(title, formatNotePlaceholder(currentNote), { signal });
+	if (signal?.aborted) {
+		return { kind: "cancelled", state };
+	}
 	if (value === undefined) {
-		return { done: true, step: { cancelled: true, state } };
+		return { kind: "back", state };
 	}
 	return {
-		done: false,
+		kind: "saved",
 		state: updateAnswer(state, question.id, (answer) =>
 			saveQuestionNote(answer, value)
 		),
@@ -449,14 +525,18 @@ async function editOptionNote(
 	state: AskState,
 	question: AskQuestion,
 	questionIndex: number,
-	action: NoteAction
-): Promise<NoteActionResult> {
+	action: NoteAction,
+	signal?: AbortSignal
+): Promise<RpcEditResult> {
+	if (signal?.aborted) {
+		return { kind: "cancelled", state };
+	}
 	const optionValue = action.optionValue;
 	const option = question.options.find(
 		(candidate) => candidate.value === optionValue
 	);
 	if (!(optionValue && option)) {
-		return { done: true, step: { cancelled: true, state } };
+		return { kind: "cancelled", state };
 	}
 	const value = await ui.editor(
 		formatTitle(
@@ -467,11 +547,14 @@ async function editOptionNote(
 		),
 		state.answers[question.id]?.optionNotes?.[optionValue] ?? ""
 	);
+	if (signal?.aborted) {
+		return { kind: "cancelled", state };
+	}
 	if (value === undefined) {
-		return { done: true, step: { cancelled: true, state } };
+		return { kind: "back", state };
 	}
 	return {
-		done: false,
+		kind: "saved",
 		state: updateAnswer(state, question.id, (answer) =>
 			saveOptionNote(answer, optionValue, value)
 		),
@@ -481,24 +564,40 @@ async function editOptionNote(
 async function selectAction(
 	ui: RpcUi,
 	title: string,
-	actions: SelectAction[]
+	actions: SelectAction[],
+	signal?: AbortSignal
 ): Promise<SelectAction | undefined> {
+	if (signal?.aborted) {
+		return;
+	}
 	const selected = await ui.select(
 		title,
-		actions.map((action) => action.label)
+		actions.map((action) => action.label),
+		{ signal }
 	);
+	if (signal?.aborted) {
+		return;
+	}
 	return actions.find((action) => action.label === selected);
 }
 
 async function selectNoteAction(
 	ui: RpcUi,
 	title: string,
-	actions: NoteAction[]
+	actions: NoteAction[],
+	signal?: AbortSignal
 ): Promise<NoteAction | undefined> {
+	if (signal?.aborted) {
+		return;
+	}
 	const selected = await ui.select(
 		title,
-		actions.map((action) => action.label)
+		actions.map((action) => action.label),
+		{ signal }
 	);
+	if (signal?.aborted) {
+		return;
+	}
 	return actions.find((action) => action.label === selected);
 }