Method askUserQuestion

packages/runtime/src/tool-runtime.ts:2095–2188

(
    turnId: string,
    toolUseId: string,
    questions: UserQuestion[],
    abortSignal: AbortSignal,
    queue: DurableSessionEventSink,
  )

  }

  private async askUserQuestion(
    turnId: string,
    toolUseId: string,
    questions: UserQuestion[],
    abortSignal: AbortSignal,
    queue: DurableSessionEventSink,
  ): Promise<UserQuestionResult> {
    throwIfAborted(abortSignal);
    const hostedRun = this.interactionRun();
    const requestId = this.input.newId();
    const parked = this.userQuestions.park(requestId, {
      toolUseId,
      questions,
      hosted: hostedRun !== undefined,
    });
    const onAbort = (): void => {
      if (hostedRun) return;
      this.userQuestions.reject(requestId, abortErrorFromSignal(abortSignal));
      this.finishDeferredQuestionTurnClosure();
    };
    abortSignal.addEventListener('abort', onAbort, { once: true });
    if (hostedRun) void parked.catch(() => undefined);
    try {
      const request: UserQuestionRequestEvent = {
        type: 'user_question_request',
        id: this.input.newId(),
        turnId,
        ts: this.input.now(),
        requestId,
        toolUseId,
        questions,
      };
      if (hostedRun) {
        const settlement = this.createUserQuestionSettlement(turnId, requestId);
        const admission = hostedRun.admitUserQuestionRequest({ request, settlement });
        try {
          await racePromiseWithAbort(admission, abortSignal);
        } catch (error) {
          if (abortSignal.aborted) {
            void admission.catch((admissionError) => {
              this.userQuestions.reject(
                requestId,
                admissionError instanceof Error
                  ? admissionError
                  : new RuntimeInteractionFailStopError(
                      `Could not confirm admission for question ${requestId}`,
                      admissionError,
                    ),
              );
              this.finishDeferredQuestionTurnClosure();
            });
            throw abortErrorFromSignal(abortSignal);
          }
          this.userQuestions.reject(
            requestId,
            error instanceof Error
              ? error
              : new RuntimeInteractionFailStopError(