@evandu/super-pi 0.1.40 → 0.1.42

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-DlKKZuzf.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C6BogHc-.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("；")}` };
+            };
         });
     }
     /**
@@ -283,6 +314,11 @@ export class RunService {
         // an order that never happened. The runtime calls `onToolCall` synchronously between yields, so a
         // counter advanced once per yielded delta is the real position of the call in the answer.
         let spoken = 0;
+        // AND HOW MUCH REASONING HAD BEEN STREAMED, for the same reason and from the same place. The store's
+        // `message.thinking` is only updated at the end of the turn (in `finally`), so it cannot be read here.
+        // The running total is what lets a call made during reasoning anchor inside the thinking block rather than
+        // after it, which is the order the events had.
+        let thought = 0;
         /**
          * ONE COUNTER FOR EVERY ROW, AND THE ONLY WAY A ROW NUMBER IS EVER MADE.
          *
@@ -333,6 +369,7 @@ export class RunService {
                 ...(call.detail ? { detail: call.detail } : { detail: "正在生成参数…" }),
                 preparing: true,
                 at,
+                thinkingAt: thought,
             }));
             preparingRows.set(call.contentIndex, { row, name: call.name });
         };
@@ -364,7 +401,7 @@ export class RunService {
             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, ...(call.question ? { question: call.question } : {}) }));
+            enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args, at, thinkingAt: thought, ...(call.question ? { question: call.question } : {}) }));
         };
         const onToolUpdate = (call) => {
             const index = call.id ? rowByToolCallId.get(call.id) : undefined;
@@ -390,7 +427,14 @@ 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) => {
+                thought += delta.length;
+                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);
@@ -593,36 +637,38 @@ export class RunService {
                 const result = run.status === "completed" ? run.output ?? "" : `Background task failed: ${run.error ?? run.status}`;
                 const tag = run.status === "completed" ? "task_result" : "task_error";
                 const message = `<task id="${run.id}" state="${run.status === "completed" ? "completed" : "error"}">\n<summary>Background task ${run.status === "completed" ? "completed" : "failed"}: ${body.description?.trim() || subagentType}</summary>\n<${tag}>\n${result}\n</${tag}>\n</task>`;
-                // Background results are durable follow-up material. Keep them visible in the queue until the
-                // user sends the next prompt; injecting a result into an idle conversation starts an unexpected
-                // model turn and makes the result disappear before the Queue Dock can render it.
-                try {
-                    if (this.activeRuns.has(conversation.id))
-                        await this.enqueueAndRun(conversation.id, message);
-                    else
-                        await this.store.enqueueMessage(conversation.id, message);
-                }
-                catch (error) {
+                // A BACKGROUND RESULT IS A PROMPT, AND DELIVERING IT IS NOT TRIGGERING IT.
+                //
+                // This used to park it in the queue until the reader sent the next prompt, which is the hole the
+                // queue exists to avoid: nothing owned it. `takeNextQueuedMessage` is only ever called from
+                // inside a turn, so a result arriving at an IDLE conversation sat in the dock forever - and when
+                // the reader tried to steer it, the runtime refused with 「会话 X 现在没有正在运行的 Pi 进程」,
+                // because of course there was no run: the message had been waiting for one nobody would start.
+                //
+                // `enqueueAndRun` is the owner this needed. It claims the run slot synchronously, so it starts a
+                // turn when the conversation is idle and enqueues when one is running - and the turn it starts
+                // drains whatever follows. One call, and no queued message is ever left without a scheduled reader.
+                // HANDED OFF, NOT AWAITED. `enqueueAndRun` resolves when the whole turn it started has FINISHED,
+                // and this handler owns the `backgroundTasks` row - so awaiting it here kept that row on screen
+                // for the entire delivered answer, a finished task wearing its own 「running」 state. The row is
+                // removed as soon as the result has a home, which is what its lifecycle means.
+                const started = this.enqueueAndRun(conversation.id, message);
+                await this.store.removeBackgroundTask(run.id);
+                this.broadcaster.broadcastState();
+                await started.catch(async (error) => {
+                    // The turn could not start, so the result has nowhere to be read from. Put it back in the queue,
+                    // where it is at least visible and cancellable, rather than dropping it on the floor.
                     await this.store.enqueueMessage(conversation.id, message);
-                    console.warn(`Super Pi: background result could not start a turn: ${error instanceof Error ? error.message : "unknown error"}`);
-                }
-                finally {
-                    await this.store.removeBackgroundTask(run.id);
                     this.broadcaster.broadcastState();
-                }
+                    console.warn(`Super Pi: background result could not start a turn: ${error instanceof Error ? error.message : "unknown error"}`);
+                });
             }).catch(async (error) => {
                 const message = `<task id="${backgroundId}" state="error">\n<summary>Background task failed: ${body.description?.trim() || subagentType}</summary>\n<task_error>Background task failed before completion: ${error instanceof Error ? error.message : "unknown error"}</task_error>\n</task>`;
-                try {
-                    if (this.activeRuns.has(conversationId))
-                        await this.enqueueAndRun(conversationId, message);
-                    else
-                        await this.store.enqueueMessage(conversationId, message);
-                }
-                catch {
-                    await this.store.enqueueMessage(conversationId, message);
-                }
+                // The same rule as the task result above, and the same shape: hand it off, then drop the row.
+                const started = this.enqueueAndRun(conversationId, message);
                 await this.store.removeBackgroundTask(backgroundId);
                 this.broadcaster.broadcastState();
+                await started.catch(async () => { await this.store.enqueueMessage(conversationId, message); this.broadcaster.broadcastState(); });
                 console.warn(`Super Pi: background sub-agent dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
             }));
             return {

package/dist/server/runtime.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { resolve, join } from "node:path";
 import { agentSpawnArgs, readAgents } from "./agents.js";
 import { TASK_CAPABILITY_ENV, mintCapability, releaseCapability } from "./capability.js";
@@ -779,7 +779,6 @@ export class PiRpcRuntime {
                     } : {}) } } : {}),
         });
         const channel = new RpcChannel(child);
-        this.runs.set(conversation.id, { child, channel });
         // Same guard as subagents.ts: a destroyed stdin throws synchronously on write, and an abort
         // listener that throws inside a listener would surface as an unhandled error instead of a cancel.
         const abort = () => {
@@ -994,6 +993,7 @@ export class PiRpcRuntime {
                     }
                     if (record.type === "message_update") {
                         const event = record.assistantMessageEvent;
+                        console.log(`[runtime] message_update event.type=${JSON.stringify(event?.type)}`);
                         // text_delta is what drives the visible answer, and toolcall_start/delta/end are what make a
                         // call VISIBLE WHILE IT IS BEING WRITTEN.
                         //
@@ -1027,8 +1027,10 @@ export class PiRpcRuntime {
                         }
                         else if (event?.type === "thinking_delta")
                             onThinking?.(typeof event.delta === "string" ? event.delta : "");
-                        else
+                        else {
                             noteUnhandled(`message_update:${JSON.stringify(event?.type ?? "(missing)")}`);
+                            console.log(`[runtime] message_update not matched: event.type=${JSON.stringify(event?.type)}`);
+                        }
                         continue;
                     }
                     if (record.type === "extension_ui_request") {

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.
@@ -894,7 +913,22 @@ export class Store {
         // halves: the call arrived, and the message already holds every character streamed before it. Without
         // it the browser can only render the blocks as one list beside the text, so a turn that read a file,
         // said something, then ran a test would show all three in the wrong order.
-        calls.push(structuredClone(call.at === undefined ? { ...call, at: message.content.length } : call));
+        //
+        // AND WHERE IN THE REASONING, for the same reason and from the same place. `thinking` is the other
+        // stream a turn has, and a call made while the model was still thinking has to be placeable inside it -
+        // otherwise the transcript can only say "it reasoned, and then it called a tool", which is the one order
+        // a `hmm → read → hmm → grep → answer` turn never had. Stamped as the thinking length BEFORE this call,
+        // so a call that started before any reasoning anchors at 0 and renders first.
+        //
+        // The thinking read here is the message's own field, written synchronously as each delta arrives - not
+        // a count of how much a queued disk write had managed to flush. That distinction is the same one `at`
+        // was stamped for.
+        const placed = {
+            ...call,
+            ...(call.at === undefined ? { at: message.content.length } : {}),
+            ...(call.thinkingAt === undefined ? { thinkingAt: (message.thinking ?? "").length } : {}),
+        };
+        calls.push(structuredClone(placed));
         conversation.updatedAt = now();
         await this.persist();
         return structuredClone(calls);

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/dist/server/types.d.ts

@@ -167,7 +167,23 @@ export type ToolCallBlock = {
      * the only thing on screen during a long parameter stream - an 'edit' block carries a whole file's
      * replacement text, and without this the screen is blank until the last token arrives. */
     preparing?: boolean;
+    /**
+     * WHERE IN THE ANSWER the call happened, as a character offset into `content` - and WHERE IN THE
+     * REASONING, as an offset into `thinking`.
+     *
+     * A TURN HAS TWO STREAMS, and a call belongs to a position in each. `at` places it among the words the
+     * agent spoke; `thinkingAt` places it inside the reasoning it did before speaking, which is what lets a
+     * call that happened mid-thought render INSIDE the thinking block rather than beside it. Without the
+     * second offset a tool call can only be stacked after the reasoning, which reads as "the model thought,
+     * and then, separately, called a tool" - the order the events did not have.
+     *
+     * OPTIONAL, and absent means "this call's place in the reasoning was never recorded" - a message written
+     * before the field existed. A reader that guesses a position for such a call would be re-ordering a turn
+     * on no evidence, so it must fall back to `at` alone, which is exactly what those blocks were written to
+     * be read by.
+     */
     at?: number;
+    thinkingAt?: number;
     question?: ToolCallQuestion;
 };
 /**

package/package.json

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