@evandu/super-pi 0.1.40 → 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-Dxm2Vtis.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DuqJLo6R.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.js

@@ -110,35 +110,66 @@ export class RunService {
      * backfilled with `options[0]`.
      */
     async askQuestion(conversationId) {
-        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
-        const message = conversation?.messages.slice().reverse().find((item) => item.role === "assistant");
-        if (!message)
-            throw new Error("No active assistant message");
-        // THE CALL, NOT THE MESSAGE. The newest `question` call still marked pending is the one the model is
-        // blocked inside; anything else would attach an answer to a question nobody is waiting on.
-        let index = -1;
-        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") {
-                index = i;
-                break;
+        // 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));
         }
-        if (index < 0)
+        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+        if (!conversation?.messages.length)
+            throw new Error("No active assistant message");
+        if (!found)
             throw new Error("这个会话里没有正在等待回答的 question 工具调用");
-        const messageId = message.id;
+        const { messageId, index } = found;
         return new Promise((resolve, reject) => {
             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({ answers: current.answers ?? [] }));
+                    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);
             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("；")}` };
+            };
         });
     }
     /**
@@ -390,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/store.d.ts

@@ -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.

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.

package/dist/server/tool-calls.js

@@ -140,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;

package/package.json

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