Handle Grok user question cancellation explicitly

Author: Jaaneek

apps/server/scripts/acp-mock-agent.ts

@@ -566,6 +566,7 @@ const program = Effect.gen(function* () {
             questions: [
               {
                 question: "Which scope should Grok use?",
+                multiSelect: null,
                 options: [
                   { label: "Workspace", description: "Use the current workspace" },
                   { label: "Session", description: "Only use this session" },

apps/server/src/provider/Layers/GrokAdapter.ts

@@ -59,6 +59,7 @@ import {
 } from "../acp/GrokAcpSupport.ts";
 import {
   extractXAiAskUserQuestions,
+  makeXAiAskUserQuestionCancelledResponse,
   makeXAiAskUserQuestionResponse,
   XAiAskUserQuestionRequest,
 } from "../acp/XAiAcpExtension.ts";
@@ -86,8 +87,12 @@ interface PendingApproval {
   readonly decision: Deferred.Deferred<ProviderApprovalDecision>;
 }
 
+type PendingUserInputResolution =
+  | { readonly _tag: "answered"; readonly answers: ProviderUserInputAnswers }
+  | { readonly _tag: "cancelled" };
+
 interface PendingUserInput {
-  readonly answers: Deferred.Deferred<ProviderUserInputAnswers>;
+  readonly resolution: Deferred.Deferred<PendingUserInputResolution>;
 }
 
 interface GrokSessionContext {
@@ -116,12 +121,12 @@ function settlePendingApprovalsAsCancelled(
   );
 }
 
-function settlePendingUserInputsAsEmptyAnswers(
+function settlePendingUserInputsAsCancelled(
   pendingUserInputs: ReadonlyMap<ApprovalRequestId, PendingUserInput>,
 ): Effect.Effect<void> {
   return Effect.forEach(
     Array.from(pendingUserInputs.values()),
-    (pending) => Deferred.succeed(pending.answers, {}).pipe(Effect.ignore),
+    (pending) => Deferred.succeed(pending.resolution, { _tag: "cancelled" }).pipe(Effect.ignore),
     { discard: true },
   );
 }
@@ -308,7 +313,7 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte
         if (ctx.stopped) return;
         ctx.stopped = true;
         yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals);
-        yield* settlePendingUserInputsAsEmptyAnswers(ctx.pendingUserInputs);
+        yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs);
         if (ctx.notificationFiber) {
           yield* Fiber.interrupt(ctx.notificationFiber);
         }
@@ -395,8 +400,8 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte
                       yield* logNative(input.threadId, method, params);
                       const requestId = ApprovalRequestId.make(yield* randomUUIDv4);
                       const runtimeRequestId = RuntimeRequestId.make(requestId);
-                      const answers = yield* Deferred.make<ProviderUserInputAnswers>();
-                      pendingUserInputs.set(requestId, { answers });
+                      const resolution = yield* Deferred.make<PendingUserInputResolution>();
+                      pendingUserInputs.set(requestId, { resolution });
                       yield* offerRuntimeEvent({
                         type: "user-input.requested",
                         ...(yield* makeEventStamp()),
@@ -411,23 +416,29 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte
                           payload: params,
                         },
                       });
-                      const resolved = yield* Deferred.await(answers);
+                      const resolved = yield* Deferred.await(resolution);
                       pendingUserInputs.delete(requestId);
+                      const resolvedAnswers = resolved._tag === "answered" ? resolved.answers : {};
                       yield* offerRuntimeEvent({
                         type: "user-input.resolved",
                         ...(yield* makeEventStamp()),
                         provider: PROVIDER,
                         threadId: input.threadId,
                         turnId: sessions.get(input.threadId)?.activeTurnId,
                         requestId: runtimeRequestId,
-                        payload: { answers: resolved },
+                        payload: { answers: resolvedAnswers },
                         raw: {
                           source: "acp.grok.extension",
                           method,
                           payload: params,
                         },
                       });
-                      return makeXAiAskUserQuestionResponse(resolved);
+                      switch (resolved._tag) {
+                        case "answered":
+                          return makeXAiAskUserQuestionResponse(params, resolved.answers);
+                        case "cancelled":
+                          return makeXAiAskUserQuestionCancelledResponse();
+                      }
                     }),
                   ),
                 ),
@@ -804,7 +815,7 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte
       Effect.gen(function* () {
         const ctx = yield* requireSession(threadId);
         yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals);
-        yield* settlePendingUserInputsAsEmptyAnswers(ctx.pendingUserInputs);
+        yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs);
         yield* Effect.ignore(
           ctx.acp.cancel.pipe(
             Effect.mapError((error) =>
@@ -847,7 +858,7 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte
             detail: `Unknown pending user-input request: ${requestId}`,
           });
         }
-        yield* Deferred.succeed(pending.answers, answers);
+        yield* Deferred.succeed(pending.resolution, { _tag: "answered", answers });
       });
 
     const readThread: GrokAdapterShape["readThread"] = (threadId) =>

apps/server/src/provider/acp/XAiAcpExtension.test.ts

@@ -1,7 +1,12 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 import * as Schema from "effect/Schema";
 
-import { extractXAiAskUserQuestions, XAiAskUserQuestionRequest } from "./XAiAcpExtension.ts";
+import {
+  extractXAiAskUserQuestions,
+  makeXAiAskUserQuestionCancelledResponse,
+  makeXAiAskUserQuestionResponse,
+  XAiAskUserQuestionRequest,
+} from "./XAiAcpExtension.ts";
 
 const decodeXAiAskUserQuestionRequest = Schema.decodeUnknownSync(XAiAskUserQuestionRequest);
 
@@ -39,7 +44,7 @@ describe("XAiAcpExtension", () => {
 
   it("extracts questions from wrapped _x.ai extension payloads", () => {
     const payload = {
-      method: "x.ai/ask_user_question",
+      method: "_x.ai/ask_user_question",
       params: {
         sessionId: "session-1",
         toolCallId: "tool-call-1",
@@ -69,4 +74,177 @@ describe("XAiAcpExtension", () => {
       },
     ]);
   });
+
+  it("treats nullable multiSelect from Grok as single-select", () => {
+    const questions = extractXAiAskUserQuestions({
+      sessionId: "session-1",
+      toolCallId: "tool-call-1",
+      mode: "default",
+      questions: [
+        {
+          question: "Which label should Grok use?",
+          multiSelect: null,
+          options: [
+            { label: "Alpha", description: "Use the Alpha label" },
+            { label: "Beta", description: "Use the Beta label" },
+            { label: "Other", description: "Use the Other label" },
+          ],
+        },
+      ],
+    });
+
+    expect(questions).toEqual([
+      {
+        id: "Which label should Grok use?",
+        header: "Question",
+        question: "Which label should Grok use?",
+        multiSelect: false,
+        options: [
+          { label: "Alpha", description: "Use the Alpha label" },
+          { label: "Beta", description: "Use the Beta label" },
+          { label: "Other", description: "Use the Other label" },
+        ],
+      },
+    ]);
+  });
+
+  it("maps UI question ids back to xAI question text in accepted responses", () => {
+    const response = makeXAiAskUserQuestionResponse(
+      {
+        sessionId: "session-1",
+        toolCallId: "tool-call-1",
+        mode: "default",
+        questions: [
+          {
+            id: "scope",
+            question: "Which scope should Grok use?",
+            options: [
+              { label: "workspace", description: "Use the current workspace" },
+              { label: "session", description: "Only use this session" },
+            ],
+          },
+        ],
+      },
+      { scope: "workspace" },
+    );
+
+    expect(response).toEqual({
+      outcome: "accepted",
+      answers: {
+        "Which scope should Grok use?": ["workspace"],
+      },
+    });
+  });
+
+  it("orders accepted answers by the original xAI question order", () => {
+    const response = makeXAiAskUserQuestionResponse(
+      {
+        sessionId: "session-1",
+        toolCallId: "tool-call-1",
+        mode: "default",
+        questions: [
+          {
+            id: "first",
+            question: "First question?",
+            options: [{ label: "A", description: "A" }],
+          },
+          {
+            id: "second",
+            question: "Second question?",
+            options: [{ label: "B", description: "B" }],
+          },
+        ],
+      },
+      {
+        second: "B",
+        first: "A",
+      },
+    );
+
+    expect(Object.keys(response.answers)).toEqual(["First question?", "Second question?"]);
+    expect(response).toMatchObject({
+      outcome: "accepted",
+      answers: {
+        "First question?": ["A"],
+        "Second question?": ["B"],
+      },
+    });
+  });
+
+  it("encodes typed custom answers as xAI Other annotations", () => {
+    const response = makeXAiAskUserQuestionResponse(
+      {
+        method: "x.ai/ask_user_question",
+        params: {
+          sessionId: "session-1",
+          toolCallId: "tool-call-1",
+          mode: "default",
+          questions: [
+            {
+              question: "Which ice cream flavor?",
+              options: [
+                { label: "vanilla", description: "Vanilla flavor" },
+                { label: "chocolate", description: "Chocolate flavor" },
+              ],
+            },
+          ],
+        },
+      },
+      { "Which ice cream flavor?": "pistachio" },
+    );
+
+    expect(response).toEqual({
+      outcome: "accepted",
+      answers: {
+        "Which ice cream flavor?": ["Other"],
+      },
+      annotations: {
+        "Which ice cream flavor?": {
+          notes: "pistachio",
+        },
+      },
+    });
+  });
+
+  it("encodes interrupted dialogs as xAI cancelled responses", () => {
+    expect(makeXAiAskUserQuestionCancelledResponse()).toEqual({
+      outcome: "cancelled",
+    });
+  });
+
+  it("does not echo preview annotations for multi-select answers", () => {
+    const response = makeXAiAskUserQuestionResponse(
+      {
+        sessionId: "session-1",
+        toolCallId: "tool-call-1",
+        mode: "default",
+        questions: [
+          {
+            question: "Which files should Grok touch?",
+            multiSelect: true,
+            options: [
+              {
+                label: "Tests",
+                description: "Update tests",
+                preview: "test preview",
+              },
+              {
+                label: "Docs",
+                description: "Update docs",
+                preview: "docs preview",
+              },
+            ],
+          },
+        ],
+      },
+      { "Which files should Grok touch?": ["Tests", "Docs"] },
+    );
+
+    expect(response).toEqual({
+      outcome: "accepted",
+      answers: {
+        "Which files should Grok touch?": ["Tests", "Docs"],
+      },
+    });
+  });
 });