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

@@ -314,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.
          *
@@ -364,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 });
         };
@@ -395,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;
@@ -425,6 +431,7 @@ export class RunService {
             // 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);
             },
@@ -630,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.js

@@ -913,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/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.41",
+  "version": "0.1.42",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",