@evandu/super-pi 0.1.39 → 0.1.41

package/dist/client/index.html

@@ -8,8 +8,8 @@
     <link rel="alternate icon" href="/favicon.ico" />
     <link rel="apple-touch-icon" href="/favicon.svg" />
     <title>Super Pi</title>
-    <script type="module" crossorigin src="/assets/index-DSJuo0Bi.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DX1yjXR8.css">
+    <script type="module" crossorigin src="/assets/index-Dihs8Ezc.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DTd4g0h5.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/application/run-service.d.ts

@@ -1,7 +1,7 @@
 import type { Store } from "../store.js";
 import type { AgentRuntime } from "../runtime.js";
 import type { SubagentRunRecorder } from "../subagent-runs.js";
-import type { Conversation, Message, MessageImage, PiQueueSnapshot, Workspace } from "../types.js";
+import type { Conversation, Message, MessageImage, PiQueueSnapshot, QuestionAnswer, Workspace } from "../types.js";
 import type { EventBroadcaster } from "../server-context.js";
 import type { ExtensionUiService } from "./extension-ui-service.js";
 import type { WorkflowEngine } from "../workflow-engine.js";
@@ -56,20 +56,36 @@ export declare class RunService {
     private readonly detached;
     constructor(store: Store, runtime: AgentRuntime, subagents: SubagentRunRecorder, broadcaster: EventBroadcaster, extensionUiService: ExtensionUiService, agentsDir: string | string[], workflows: WorkflowEngine);
     setAgentsDir(dir: string | string[]): void;
+    /**
+     * RECORDS WHAT THE PERSON CHOSE, ON THE `question` CALL THAT ASKED.
+     *
+     * The call is addressed by its index in the message's `toolCalls`, which is the same addressing every
+     * other tool update uses - and the client can only get that index from the row it is already rendering.
+     */
     answerQuestion(command: {
         conversationId: string;
         messageId: string;
-        questionId: string;
-        selected?: string[];
-        extraNote?: string;
+        callIndex: number;
+        answers?: QuestionAnswer[];
         cancelled?: boolean;
     }): Promise<void>;
-    askQuestion(conversationId: string, question: {
-        question: string;
-        options: string[];
-        multiple?: boolean;
-        extraNote?: boolean;
-    }): Promise<unknown>;
+    /**
+     * THE `question` TOOL BLOCKS HERE, ON THE CALL THAT ASKED IT.
+     *
+     * It used to APPEND A BLOCK TO THE MESSAGE and poll the store for an answer, which meant the question
+     * had no position in the answer at all: the card rendered after everything the model said, so the text
+     * streamed in response to the answer appeared ABOVE the card it was answering. The call is already on
+     * screen, already positioned by its `at`, already persisted, already reloads - so the pending wait is
+     * registered against it and nothing else is created.
+     *
+     * A DISMISSAL FAILS THE CALL. It used to resolve with `{cancelled:true}` and let the run continue, so
+     * closing a card handed the model a turn it would answer as though it had been told something. OpenCode
+     * is unambiguous about this and is the reference here: rejecting a question fails the deferred, the tool
+     * dies and the run is interrupted (`packages/core/src/question.ts:128-141`). Nothing is invented to fill
+     * the gap - the same rule the Extension UI path already follows, where a cancelled method is never
+     * backfilled with `options[0]`.
+     */
+    askQuestion(conversationId: string): Promise<unknown>;
     /**
      * Resolves the conversation and workspace synchronously for a run.
      */

package/dist/server/application/run-service.js

@@ -74,30 +74,102 @@ export class RunService {
     setAgentsDir(dir) {
         this.agentsDir = dir;
     }
+    /**
+     * RECORDS WHAT THE PERSON CHOSE, ON THE `question` CALL THAT ASKED.
+     *
+     * The call is addressed by its index in the message's `toolCalls`, which is the same addressing every
+     * other tool update uses - and the client can only get that index from the row it is already rendering.
+     */
     async answerQuestion(command) {
-        const blocks = await this.store.answerQuestion(command.conversationId, command.messageId, command.questionId, command);
-        this.broadcaster.broadcast({ type: "message.questions", conversationId: command.conversationId, messageId: command.messageId, questionBlocks: blocks });
+        const existing = this.store.snapshot().conversations.find((item) => item.id === command.conversationId)?.messages.find((item) => item.id === command.messageId)?.toolCalls?.[command.callIndex]?.question;
+        if (!existing)
+            throw new Error("这个工具调用不是一个问题");
+        const calls = await this.store.updateToolCall(command.conversationId, command.messageId, command.callIndex, {
+            question: {
+                items: existing.items,
+                status: command.cancelled ? "cancelled" : "answered",
+                ...(command.cancelled ? {} : { answers: command.answers ?? [] }),
+            },
+        });
+        this.broadcaster.broadcast({ type: "message.tools", conversationId: command.conversationId, messageId: command.messageId, toolCalls: calls });
     }
-    async askQuestion(conversationId, question) {
+    /**
+     * THE `question` TOOL BLOCKS HERE, ON THE CALL THAT ASKED IT.
+     *
+     * It used to APPEND A BLOCK TO THE MESSAGE and poll the store for an answer, which meant the question
+     * had no position in the answer at all: the card rendered after everything the model said, so the text
+     * streamed in response to the answer appeared ABOVE the card it was answering. The call is already on
+     * screen, already positioned by its `at`, already persisted, already reloads - so the pending wait is
+     * registered against it and nothing else is created.
+     *
+     * A DISMISSAL FAILS THE CALL. It used to resolve with `{cancelled:true}` and let the run continue, so
+     * closing a card handed the model a turn it would answer as though it had been told something. OpenCode
+     * is unambiguous about this and is the reference here: rejecting a question fails the deferred, the tool
+     * dies and the run is interrupted (`packages/core/src/question.ts:128-141`). Nothing is invented to fill
+     * the gap - the same rule the Extension UI path already follows, where a cancelled method is never
+     * backfilled with `options[0]`.
+     */
+    async askQuestion(conversationId) {
+        // THE ROW ARRIVES AFTER THE REQUEST, AND THAT IS A RACE, NOT A BUG IN THE CALLER.
+        //
+        // The extension lives INSIDE the Pi process. When Pi starts running the tool it writes
+        // `tool_execution_start` to stdout AND calls the tool - so the tool's HTTP request can reach this
+        // server while the transcript drain loop is still reading that very record off the pipe. The endpoint
+        // therefore asked for a tool call that had not been stored yet, and answered 「这个会话里没有正在
+        // 等待回答的 question 工具调用」 - which is a refusal, so the tool FAILED, and the person was never
+        // shown the question at all.
+        //
+        // So the lookup WAITS. A few hundred milliseconds of polling covers the drain, and a question that
+        // genuinely has no pending call still fails - just not instantly.
+        const findCall = () => {
+            const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+            const message = conversation?.messages.slice().reverse().find((item) => item.role === "assistant");
+            if (!message)
+                return undefined;
+            for (let i = (message.toolCalls?.length ?? 0) - 1; i >= 0; i -= 1) {
+                const call = message.toolCalls?.[i];
+                if (call?.label === "question" && call.question?.status === "pending")
+                    return { messageId: message.id, index: i };
+            }
+            return undefined;
+        };
+        let found;
+        for (let attempt = 0; attempt < 50 && !found; attempt += 1) {
+            found = findCall();
+            if (found)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
         const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
-        const message = conversation?.messages.slice().reverse().find((item) => item.role === "assistant");
-        if (!message)
+        if (!conversation?.messages.length)
             throw new Error("No active assistant message");
-        const block = await this.store.appendQuestion(conversationId, message.id, { question: question.question, options: question.options, multiple: question.multiple === true });
-        this.broadcaster.broadcast({ type: "message.questions", conversationId, messageId: message.id, questionBlocks: [...(message.questionBlocks ?? []), block] });
+        if (!found)
+            throw new Error("这个会话里没有正在等待回答的 question 工具调用");
+        const { messageId, index } = found;
         return new Promise((resolve, reject) => {
-            const timer = setInterval(() => {
-                const current = this.store.snapshot().conversations.find((item) => item.id === conversationId)?.messages.find((item) => item.id === message.id)?.questionBlocks?.find((item) => item.id === block.id);
-                if (current?.status === "answered") {
-                    clearInterval(timer);
-                    resolve({ selected: current.selected ?? [], extraNote: current.extraNote ?? "" });
-                }
-                else if (current?.status === "cancelled") {
-                    clearInterval(timer);
-                    resolve({ cancelled: true });
-                }
+            const finish = (settle) => { clearInterval(poll); clearTimeout(deadline); settle(); };
+            const poll = setInterval(() => {
+                const current = this.store.snapshot().conversations.find((item) => item.id === conversationId)?.messages.find((item) => item.id === messageId)?.toolCalls?.[index]?.question;
+                if (current?.status === "answered")
+                    finish(() => resolve(answerPayload(current)));
+                // CANCELLED IS NOT AN ANSWER. Rejecting is what makes the tool call fail, which is what stops the
+                // run; resolving here would let the model carry on from a question the person refused to answer.
+                else if (current?.status === "cancelled")
+                    finish(() => reject(new Error("用户没有回答这个问题")));
             }, 250);
-            setTimeout(() => { clearInterval(timer); reject(new Error("Question timed out")); }, 30 * 60 * 1000);
+            const deadline = setTimeout(() => finish(() => reject(new Error("等待回答超时"))), 30 * 60 * 1000);
+            // WHAT GOES BACK TO THE MODEL IS WRITTEN FOR THE MODEL. The answers pair to their questions by id,
+            // which is what stops a person answering the second of two being recorded against the first - but an
+            // id is a UUID, and a model handed `{answers:[{id:"671b0f0b-…", selected:["发"]}]}` has to guess at
+            // what that means. It guessed, and reported a real answer as a cancellation. So the answer goes back
+            // as its questions and its choices, with a sentence naming the outcome.
+            const answerPayload = (current) => {
+                const answers = (current.answers ?? []).map((answer) => {
+                    const asked = current.items.find((item) => item.id === answer.id);
+                    return { question: asked?.question, selected: answer.selected, ...(answer.note ? { note: answer.note } : {}) };
+                });
+                return { answers, summary: `用户回答：${answers.map((answer) => answer.selected.join("、")).join("；")}` };
+            };
         });
     }
     /**
@@ -317,13 +389,13 @@ export class RunService {
                 // that never settles and one that belongs to a different call.
                 if (call.id)
                     rowByToolCallId.set(call.id, row);
-                enqueueTools("a tool call", () => this.store.updateToolCall(conversation.id, assistant.id, row, { label: call.name, detail: call.detail, args: call.args, live: "", preparing: false }));
+                enqueueTools("a tool call", () => this.store.updateToolCall(conversation.id, assistant.id, row, { label: call.name, detail: call.detail, args: call.args, live: "", preparing: false, ...(call.question ? { question: call.question } : {}) }));
                 return;
             }
             const row = rows++;
             if (call.id)
                 rowByToolCallId.set(call.id, row);
-            enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args, at }));
+            enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args, at, ...(call.question ? { question: call.question } : {}) }));
         };
         const onToolUpdate = (call) => {
             const index = call.id ? rowByToolCallId.get(call.id) : undefined;
@@ -349,7 +421,13 @@ export class RunService {
             onToolPreparing,
             onToolUpdate,
             onToolEnd,
-            onThinking: (delta) => this.broadcaster.broadcast({ type: "message.thinking", conversationId: conversation.id, messageId: assistant.id, delta, active: true }),
+            // BROADCAST AND KEEP. It used to only broadcast, into an event no one handled - so the reasoning
+            // reached nobody, live or afterwards. Both halves now happen: the browser draws the delta as it
+            // arrives, and the message keeps it so the finished turn has something to go back to.
+            onThinking: (delta) => {
+                this.broadcaster.broadcast({ type: "message.thinking", conversationId: conversation.id, messageId: assistant.id, delta, active: true });
+                void this.store.appendThinkingDelta(conversation.id, assistant.id, delta);
+            },
             images,
         })) {
             await this.store.appendAssistantDelta(conversation.id, assistant.id, delta);

package/dist/server/http-server.js

@@ -396,7 +396,7 @@ export function createHttpServer(options) {
                 const body = JSON.parse(raw);
                 if (!body.conversationId || !body.question || !Array.isArray(body.options))
                     throw new Error("invalid question");
-                const result = await runService.askQuestion(body.conversationId, { question: body.question, options: body.options, multiple: body.multiple });
+                const result = await runService.askQuestion(body.conversationId);
                 response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(result));
             }
             catch (error) {

package/dist/server/runtime.js

@@ -9,7 +9,7 @@ import { resolvePiCommand, shellQuote } from "./pi-command.js";
 import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, rosterPayload, } from "./task-tool.js";
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
-import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractToolResultText } from "./tool-calls.js";
+import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractToolResultText, readQuestionCall } from "./tool-calls.js";
 /** Deterministic offline runtime used by tests and local UI development. */
 export class WelcomeRuntime {
     async *answer({ prompt, signal }) {
@@ -956,8 +956,12 @@ export class PiRpcRuntime {
                         // word, because an `edit`'s arguments routinely hold a whole file's replacement text. See
                         // tool-calls.ts for the argument-vs-transcript line.
                         const name = record.toolName ?? "unknown";
+                        // A `question` CALL is read here, at `tool_execution_start`, rather than assembled somewhere
+                        // else when the answer arrives - so the card on screen is the tool call the model is actually
+                        // blocked in, with the same identity, the same `at`, and the same lifecycle. `args` stays the
+                        // display reduction; this is the one call whose arguments are also the transcript's data.
                         try {
-                            onToolCall?.({ id: record.toolCallId ?? "", name, detail: describeToolCall(name, record.args), args: describeToolCallArgs(record.args) });
+                            onToolCall?.({ id: record.toolCallId ?? "", name, detail: describeToolCall(name, record.args), args: describeToolCallArgs(record.args), ...(() => { const question = readQuestionCall(name, record.args); return question ? { question } : {}; })() });
                         }
                         catch (error) {
                             console.warn(`PiRpcRuntime: the tool call handler threw: ${error instanceof Error ? error.message : "unknown error"}`);

package/dist/server/store.d.ts

@@ -1,7 +1,7 @@
 import type { AppStateRepository } from "./persistence/app-state-repository.js";
 import { defaultJsonStatePath } from "./persistence/json-state-repository.js";
 import type { WorkflowRun } from "./workflow.js";
-import type { AppState, Conversation, Message, MessageImage, ModelSelection, QueuedMessage, SubagentRun, SubagentRunUpdate, TodoItem, ToolCallArg, ToolCallBlock, ToolResultSummary, Workspace } from "./types.js";
+import type { AppState, Conversation, Message, MessageImage, ModelSelection, QueuedMessage, SubagentRun, SubagentRunUpdate, TodoItem, ToolCallQuestion, ToolCallArg, ToolCallBlock, ToolResultSummary, Workspace } from "./types.js";
 /** Mints the id a forked conversation will have, BEFORE its Pi transcript exists.
  *
  *  Exported because the ordering demands it and no other arrangement provides it. Pi's copied file's header
@@ -211,6 +211,17 @@ export declare class Store {
     }): Promise<Conversation>;
     beginAssistantMessage(conversationId: string, agentIdentity?: Message["agentIdentity"]): Promise<Message>;
     appendAssistantDelta(conversationId: string, messageId: string, delta: string): Promise<void>;
+    /**
+     * THE MODEL'S REASONING, APPENDED TO THE MESSAGE IT BELONGS TO.
+     *
+     * It used to be broadcast and nothing more: the server emitted `message.thinking` on every delta and no
+     * code anywhere read it, so the reasoning reached no one - not the screen while it streamed, and not
+     * the transcript afterwards. The field, the event and the stylesheet were all already there; the two
+     * halves that would have used them were missing, which is why a finished turn had no visible reasoning
+     * to go back to. Persisting here rather than only in the browser is the point of its living on the
+     * message: a reasoning stream that vanishes on reload was never a record of anything.
+     */
+    appendThinkingDelta(conversationId: string, messageId: string, delta: string): Promise<void>;
     /**
      * Appends one tool call to the message it belongs to, and returns the message's whole `toolCalls`
      * array so the caller can broadcast it as one snapshot.
@@ -232,12 +243,6 @@ export declare class Store {
      * instead of as a field it does not understand.
      */
     appendToolCall(conversationId: string, messageId: string, call: ToolCallBlock): Promise<ToolCallBlock[]>;
-    appendQuestion(conversationId: string, messageId: string, question: Omit<import("./types.js").QuestionBlock, "id" | "status">): Promise<import("./types.js").QuestionBlock>;
-    answerQuestion(conversationId: string, messageId: string, questionId: string, answer: {
-        selected?: string[];
-        extraNote?: string;
-        cancelled?: boolean;
-    }): Promise<import("./types.js").QuestionBlock[]>;
     /**
      * Fills in the outcome of the call at `index`, or returns the array UNCHANGED when there is no such
      * index.
@@ -275,6 +280,7 @@ export declare class Store {
         args?: ToolCallArg[];
         live?: string;
         preparing?: boolean;
+        question?: ToolCallQuestion;
     }): Promise<ToolCallBlock[]>;
     setStatus(conversationId: string, status: Conversation["status"]): Promise<void>;
     /** The plan a revert would carry out, without carrying it out. The server reads this to stop children first. */

package/dist/server/store.js

@@ -864,6 +864,25 @@ export class Store {
         conversation.updatedAt = now();
         await this.persistTransaction({ kind: "message.replace", conversationId, message: structuredClone(message), updatedAt: conversation.updatedAt });
     }
+    /**
+     * THE MODEL'S REASONING, APPENDED TO THE MESSAGE IT BELONGS TO.
+     *
+     * It used to be broadcast and nothing more: the server emitted `message.thinking` on every delta and no
+     * code anywhere read it, so the reasoning reached no one - not the screen while it streamed, and not
+     * the transcript afterwards. The field, the event and the stylesheet were all already there; the two
+     * halves that would have used them were missing, which is why a finished turn had no visible reasoning
+     * to go back to. Persisting here rather than only in the browser is the point of its living on the
+     * message: a reasoning stream that vanishes on reload was never a record of anything.
+     */
+    async appendThinkingDelta(conversationId, messageId, delta) {
+        const conversation = this.requireConversation(conversationId);
+        const message = conversation.messages.find((item) => item.id === messageId);
+        if (!message)
+            throw new Error("Assistant message not found");
+        message.thinking = `${message.thinking ?? ""}${delta}`;
+        conversation.updatedAt = now();
+        await this.persistTransaction({ kind: "message.replace", conversationId, message: structuredClone(message), updatedAt: conversation.updatedAt });
+    }
     /**
      * Appends one tool call to the message it belongs to, and returns the message's whole `toolCalls`
      * array so the caller can broadcast it as one snapshot.
@@ -899,37 +918,6 @@ export class Store {
         await this.persist();
         return structuredClone(calls);
     }
-    async appendQuestion(conversationId, messageId, question) {
-        const message = this.requireConversation(conversationId).messages.find((item) => item.id === messageId);
-        if (!message)
-            throw new Error("Assistant message not found");
-        // `at` is WHERE IN THE ANSWER THE QUESTION WAS ASKED - the same character offset a tool call carries,
-        // and for the same reason. Without it a question is a list item with no position, so it renders after
-        // the whole message; and because the question BLOCKS, everything the model says after the answer
-        // lands in the text above it. Measured on a real turn: the model said nothing, asked, waited, and on
-        // being answered streamed 「已经调用 question 工具问完，停下来等你回答」 - which rendered ABOVE the card
-        // and read as though it had been said before the question was ever asked.
-        const block = { ...structuredClone(question), id: id("question"), status: "pending", at: message.content.length };
-        (message.questionBlocks ??= []).push(block);
-        await this.persistTransaction({ kind: "message.replace", conversationId, message: structuredClone(message), updatedAt: now() });
-        return structuredClone(block);
-    }
-    async answerQuestion(conversationId, messageId, questionId, answer) {
-        const conversation = this.requireConversation(conversationId);
-        const message = conversation.messages.find((item) => item.id === messageId);
-        if (!message?.questionBlocks)
-            throw new Error("Question not found");
-        const block = message.questionBlocks.find((item) => item.id === questionId);
-        if (!block || block.status !== "pending")
-            throw new Error("Question is no longer pending");
-        block.status = answer.cancelled ? "cancelled" : "answered";
-        if (!answer.cancelled) {
-            block.selected = [...(answer.selected ?? [])];
-            block.extraNote = answer.extraNote ?? "";
-        }
-        await this.persistTransaction({ kind: "message.replace", conversationId, message: structuredClone(message), updatedAt: now() });
-        return structuredClone(message.questionBlocks);
-    }
     /**
      * Fills in the outcome of the call at `index`, or returns the array UNCHANGED when there is no such
      * index.
@@ -1010,6 +998,9 @@ export class Store {
         }
         if (patch.live !== undefined)
             call.live = patch.live;
+        // The question rides on the call rather than beside it, so this is the only write it needs.
+        if (patch.question !== undefined)
+            call.question = patch.question;
         conversation.updatedAt = now();
         await this.persist();
         return structuredClone(calls);

package/dist/server/tool-calls.d.ts

@@ -1,4 +1,4 @@
-import type { ToolCallArg, ToolResultSummary } from "./types.js";
+import type { ToolCallArg, ToolCallQuestion, ToolResultSummary } from "./types.js";
 /**
  * Turning one Pi tool call into something a human reads, and nothing more.
  *
@@ -104,3 +104,18 @@ export declare function describeToolCallInProgress(name: string, argumentsSoFar:
  * no parameter section rather than an empty one.
  */
 export declare function describeToolCallArgs(args: unknown): ToolCallArg[] | undefined;
+/**
+ * READS A `question` CALL'S ARGUMENTS INTO THE SHAPE THE TRANSCRIPT RENDERS, OR NOTHING.
+ *
+ * Both shapes are accepted because the two references differ and both are in the wild: OpenCode sends
+ * `questions: [{ question, header, options: [{label, description}], multiple }]`
+ * (`packages/core/src/tool/question.ts:25`) and this project's own extension sends
+ * `{ question, options: string[], multiple?, extraNote? }`. A question with no options, or options that
+ * are not a list of strings, is not a question - so it returns nothing and the call renders as the
+ * ordinary tool call it is, rather than as a card with nothing in it.
+ *
+ * Ids are MINTED HERE when the caller did not send one, and that is what makes the answer pair by
+ * identity rather than by position: a person answering question 2 must not be recorded as answering
+ * question 1 because one of them was dropped.
+ */
+export declare function readQuestionCall(name: string, args: unknown): ToolCallQuestion | undefined;

package/dist/server/tool-calls.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 /**
  * Turning one Pi tool call into something a human reads, and nothing more.
  *
@@ -139,6 +140,15 @@ const oneLine = (value) => {
  * shape can be regression-tested at all.
  */
 export function describeToolCall(name, args) {
+    // A QUESTION NAMES ITSELF. The generic path reads a target-ish string out of the arguments and a
+    // question has none, so it fell through to the preparing placeholder - which left every settled
+    // question row headed 「正在生成参数…」 above the question itself. The row is the decision; the header
+    // should say which one.
+    if (name.trim().toLowerCase() === "question") {
+        const asked = readQuestionCall(name, args);
+        if (asked?.items.length)
+            return oneLine(asked.items.length === 1 ? asked.items[0].question : `${asked.items.length} 个问题`);
+    }
     if (args === null || typeof args !== "object" || Array.isArray(args))
         return undefined;
     const record = args;
@@ -252,3 +262,51 @@ export function describeToolCallArgs(args) {
     }
     return listed.length ? listed : undefined;
 }
+/**
+ * READS A `question` CALL'S ARGUMENTS INTO THE SHAPE THE TRANSCRIPT RENDERS, OR NOTHING.
+ *
+ * Both shapes are accepted because the two references differ and both are in the wild: OpenCode sends
+ * `questions: [{ question, header, options: [{label, description}], multiple }]`
+ * (`packages/core/src/tool/question.ts:25`) and this project's own extension sends
+ * `{ question, options: string[], multiple?, extraNote? }`. A question with no options, or options that
+ * are not a list of strings, is not a question - so it returns nothing and the call renders as the
+ * ordinary tool call it is, rather than as a card with nothing in it.
+ *
+ * Ids are MINTED HERE when the caller did not send one, and that is what makes the answer pair by
+ * identity rather than by position: a person answering question 2 must not be recorded as answering
+ * question 1 because one of them was dropped.
+ */
+export function readQuestionCall(name, args) {
+    if (name !== "question")
+        return undefined;
+    const raw = args;
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const source = Array.isArray(raw.questions) ? raw.questions : [raw];
+    const items = [];
+    for (const entry of source) {
+        if (!entry || typeof entry !== "object")
+            return undefined;
+        const item = entry;
+        if (typeof item.question !== "string" || !item.question.trim())
+            return undefined;
+        if (!Array.isArray(item.options))
+            return undefined;
+        const options = item.options.map((option) => (typeof option === "string" ? option : option?.label)).filter((option) => typeof option === "string" && option.trim().length > 0);
+        // NO OPTIONS IS NOT A QUESTION. A `question` call with an empty list would render a card the person
+        // cannot answer, and the tool would then block for thirty minutes on it.
+        if (!options.length)
+            return undefined;
+        items.push({
+            id: typeof item.id === "string" && item.id ? item.id : randomUUID(),
+            ...(typeof item.header === "string" && item.header ? { header: item.header } : {}),
+            question: item.question,
+            options,
+            multiple: item.multiple === true,
+            // Defaults ON, matching the extension's own schema: a question that asked for an optional note and
+            // did not get one should show the field, not silently drop it.
+            extraNote: item.extraNote !== false,
+        });
+    }
+    return items.length ? { items, status: "pending" } : undefined;
+}

package/dist/server/types.d.ts

@@ -55,15 +55,36 @@ export type MessageImage = {
     width?: number;
     height?: number;
 };
-export type QuestionBlock = {
+/** ONE QUESTION AS THE  TOOL ASKED IT, before any answer exists.
+ *  Mirrors OpenCode's `QuestionV2.Prompt`: a stable id so the answer pairs by identity rather than by
+ *  position, a short header for a dock, and options with their own text. */
+export type QuestionItem = {
     id: string;
+    header?: string;
     question: string;
     options: string[];
     multiple: boolean;
+    extraNote: boolean;
+};
+/** WHAT THE PERSON CHOSE, paired to a `QuestionItem` by id. */
+export type QuestionAnswer = {
+    id: string;
+    selected: string[];
+    note?: string;
+};
+/**
+ * A QUESTION IS A TOOL CALL, NOT A SECOND KIND OF BLOCK.
+ *
+ * It used to be a `questionBlocks` array hung off the message, which meant the question had no place
+ * in the answer: it rendered after everything the model said, so the text streamed in response to the
+ * answer appeared ABOVE the card it was answering. The tool-call row already carries an `at` offset, is
+ * already persisted, already reloads, and already expands - so the question lives there too, and the
+ * ordering, the persistence and the replay all come from the mechanism that was already correct.
+ */
+export type ToolCallQuestion = {
+    items: QuestionItem[];
     status: "pending" | "answered" | "cancelled";
-    selected?: string[];
-    extraNote?: string;
-    at?: number;
+    answers?: QuestionAnswer[];
 };
 export type Message = {
     id: string;
@@ -72,7 +93,6 @@ export type Message = {
     createdAt: string;
     piEntryId?: string;
     toolCalls?: ToolCallBlock[];
-    questionBlocks?: QuestionBlock[];
     thinking?: string;
     images?: MessageImage[];
     agentIdentity?: {
@@ -148,6 +168,7 @@ export type ToolCallBlock = {
      * replacement text, and without this the screen is blank until the last token arrives. */
     preparing?: boolean;
     at?: number;
+    question?: ToolCallQuestion;
 };
 /**
  * ONE TOOL CALL'S OUTPUT, reduced to the part a person reads and bounded so it cannot become the
@@ -178,6 +199,7 @@ export type ToolCallNotice = {
     args?: ToolCallArg[];
     status?: "ok" | "error";
     durationMs?: number;
+    question?: ToolCallQuestion;
     result?: ToolResultSummary;
     live?: string;
     preparing?: boolean;
@@ -692,13 +714,21 @@ export type ExtensionUiAnswer = {
 export type ClientCommand = ClientCommandBody & {
     operationRequestId?: string;
 };
-export type ClientCommandBody = {
+export type ClientCommandBody = 
+/**
+ * THE ANSWER TO A `question` CALL, ADDRESSED BY THE CALL'S ROW.
+ *
+ * It used to name a `questionId` on a block hung off the message. It now names `callIndex` - the same
+ * index every other tool update uses - because the question IS that call, and the row being rendered is
+ * the only place the browser can learn the index from. Answers pair to questions by `id`, not position,
+ * so a person answering the second of two is not recorded as answering the first.
+ */
+{
     type: "question.answer";
     conversationId: string;
     messageId: string;
-    questionId: string;
-    selected?: string[];
-    extraNote?: string;
+    callIndex: number;
+    answers?: QuestionAnswer[];
     cancelled?: boolean;
 }
 /**
@@ -1051,11 +1081,6 @@ export type ServerEvent = {
     conversationId: string;
     messageId: string;
     toolCalls: ToolCallBlock[];
-} | {
-    type: "message.questions";
-    conversationId: string;
-    messageId: string;
-    questionBlocks: QuestionBlock[];
 } | {
     type: "error";
     message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",