@evandu/super-pi 0.1.76 → 0.1.78

package/dist/server/runtime.d.ts

@@ -100,8 +100,11 @@ export interface AnswerInput {
      * replacement text, and one that shows the call arriving.
      */
     onToolPreparing?(call: ToolCallPreparing): void;
-    /** Called while the primary model is emitting reasoning, so the UI can show live progress. */
+    /** Called while the primary model is emitting reasoning, so the UI can show live progress. A call means
+     *  the model is STILL THINKING - there is no separate flag, because Pi does not send one. */
     onThinking?(delta: string): void;
+    /** Called when the reasoning phase ends - the only signal that it has. */
+    onThinkingEnd?(): void;
 }
 /**
  * What Pi answered when a `steer` was written to it, from the `disposition` of that command's response
@@ -492,7 +495,7 @@ export declare class PiRpcRuntime implements AgentRuntime {
      * own address, so it is the same string on every turn and is read once from the constructor's options.
      */
     private taskExtensionEnv;
-    answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onSessionFile, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, onThinking, images, memoryReview, memorySourceConversationId }: AnswerInput): AsyncIterable<string>;
+    answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onSessionFile, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, onThinking, onThinkingEnd, images, memoryReview, memorySourceConversationId }: AnswerInput): AsyncIterable<string>;
     /**
      * Reads back the id of the user message this turn just created, and hands it to the caller.
      *

package/dist/server/runtime.js

@@ -398,7 +398,7 @@ export class PiRpcRuntime {
             [TASK_CAPABILITY_ENV]: capability,
         };
     }
-    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onSessionFile, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, onThinking, images, memoryReview, memorySourceConversationId }) {
+    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onSessionFile, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, onThinking, onThinkingEnd, images, memoryReview, memorySourceConversationId }) {
         const latencyStartedAt = performance.now();
         traceLatency(conversation.id, "answer.begin", latencyStartedAt);
         await mkdir(this.sessionDir, { recursive: true });
@@ -723,8 +723,14 @@ export class PiRpcRuntime {
                             const detail = describeToolCallInProgress(name, text);
                             onToolPreparing?.({ contentIndex: event.contentIndex, name, ...(text ? { live: text } : {}), ...(detail ? { detail } : {}) });
                         }
+                        // Pi's reasoning lifecycle is three events, not one flag: `thinking_delta` means the model is
+                        // STILL THINKING RIGHT NOW, and `thinking_end` is the only thing that says it stopped. There is
+                        // deliberately no `active` field read here - every `thinking_delta` in Pi's wire shape carries
+                        // `{ type, contentIndex, delta, partial }` and nothing else, so a delta is itself the evidence.
                         else if (event?.type === "thinking_delta")
                             onThinking?.(typeof event.delta === "string" ? event.delta : "");
+                        else if (event?.type === "thinking_end")
+                            onThinkingEnd?.();
                         else {
                             noteUnhandled(`message_update:${JSON.stringify(event?.type ?? "(missing)")}`);
                         }

package/dist/server/store.d.ts

@@ -241,7 +241,8 @@ export declare class Store {
      * 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.
      */
-    appendThinkingDeltaLive(conversationId: string, messageId: string, delta: string, at?: number): void;
+    appendThinkingDeltaLive(conversationId: string, messageId: string, delta: string, at?: number, newBlock?: boolean): void;
+    setThinkingActiveLive(conversationId: string, messageId: string, active: boolean): void;
     appendThinkingDelta(conversationId: string, messageId: string, delta: string): Promise<void>;
     /** Persists the message exactly as it stands now, including any live text, thinking and tool updates. */
     checkpointMessage(conversationId: string, messageId: string): Promise<void>;
@@ -304,6 +305,7 @@ export declare class Store {
         live?: string;
         preparing?: boolean;
         question?: ToolCallQuestion;
+        backgroundTask?: ToolCallBlock["backgroundTask"];
     }): 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

@@ -907,7 +907,7 @@ export class Store {
      * 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.
      */
-    appendThinkingDeltaLive(conversationId, messageId, delta, at) {
+    appendThinkingDeltaLive(conversationId, messageId, delta, at, newBlock = false) {
         const conversation = this.requireConversation(conversationId);
         const message = conversation.messages.find((item) => item.id === messageId);
         if (!message)
@@ -915,12 +915,17 @@ export class Store {
         message.thinking = `${message.thinking ?? ""}${delta}`;
         const blocks = (message.thinkingBlocks ??= []);
         const last = blocks.at(-1);
-        if (last && last.at === (at ?? last.at))
+        if (!newBlock && last && last.at === (at ?? last.at))
             last.text += delta;
         else
             blocks.push({ at: at ?? message.content.length, text: delta });
         conversation.updatedAt = now();
     }
+    setThinkingActiveLive(conversationId, messageId, active) {
+        const message = this.requireConversation(conversationId).messages.find((item) => item.id === messageId);
+        if (message)
+            message.thinkingActive = active;
+    }
     async appendThinkingDelta(conversationId, messageId, delta) {
         this.appendThinkingDeltaLive(conversationId, messageId, delta);
         await this.checkpointMessage(conversationId, messageId);
@@ -1050,6 +1055,8 @@ export class Store {
         // whatever the latest update happened to carry loses every key the update left out, which on the very
         // first update is all of them. Merging can only ever add, so a sparse update can no longer erase what
         // an earlier one already reported - and the cap is re-applied here rather than trusted from outside.
+        if (patch.backgroundTask !== undefined)
+            call.backgroundTask = structuredClone(patch.backgroundTask);
         if (patch.label !== undefined)
             call.label = patch.label;
         if (patch.detail !== undefined)

package/dist/server/subagent-runs.d.ts

@@ -41,6 +41,14 @@ export type SubagentDispatch = {
      * passes "model" explicitly.
      */
     dispatchedBy?: "human" | "model";
+    /**
+     * Where in the dispatching message this run was asked for, resolved by the caller from the tool call's
+     * id. Copied straight onto the record, because a card's position is a fact about its BIRTH - it is
+     * settled here and no update has to supply it, so the card cannot drift while the child streams.
+     * Omitted means "no call asked for it" (a person pressing the button), which is not row zero and never is.
+     */
+    originMessageId?: string;
+    originCallRow?: number;
     parentRunId?: string;
     depth?: number;
     loopId?: string;

package/dist/server/subagent-runs.js

@@ -124,7 +124,7 @@ export class SubagentRunRecorder {
         const { conversationId, agentId, task, cwd, model, denyTools, dispatchedBy = "human" } = input;
         // Generated HERE, not by `run()`, because the record has to exist first - see this file's header.
         const id = input.id ?? newSubagentRunId();
-        const started = { id, conversationId, agentId, task, dispatchedBy, parentRunId: input.parentRunId, depth: input.depth ?? 0, loopId: input.loopId, role: input.role, status: "running", startedAt: new Date().toISOString(), sessionId: id };
+        const started = { id, conversationId, agentId, task, dispatchedBy, parentRunId: input.parentRunId, depth: input.depth ?? 0, loopId: input.loopId, role: input.role, originMessageId: input.originMessageId, originCallRow: input.originCallRow, status: "running", startedAt: new Date().toISOString(), sessionId: id };
         await this.hooks.store.beginSubagentRun(started);
         // The recorder's own copy, held separately from the store's. Mutating the object `beginSubagentRun`
         // was handed would reach into the store's state behind its back, and every snapshot it hands out

package/dist/server/tool-runner.js

@@ -19,7 +19,7 @@ export class ToolRunner {
         child.stdout.on("data", (data) => { active.stdout = clipped(`${active.stdout}${data.toString("utf8")}`); });
         child.stderr.on("data", log);
         child.once("error", (error) => this.finish(id, "failed", error.message));
-        child.once("exit", (code) => {
+        child.once("close", (code) => {
             if (active.run.status !== "running")
                 return;
             if (code !== 0) {
@@ -34,7 +34,6 @@ export class ToolRunner {
                 this.finish(id, "succeeded");
             }
             catch (error) {
-                active.run.logs = clipped(`${active.run.logs}${active.stdout}`);
                 this.finish(id, "failed", `脚本没有输出一个 JSON 对象：${error instanceof Error ? error.message : "invalid output"}`);
             }
         });
@@ -48,7 +47,8 @@ export class ToolRunner {
         this.finish(id, "cancelled");
     } return copy(active.run); }
     finish(id, status, error) { const active = this.runs.get(id); if (!active || active.run.status !== "running")
-        return; clearTimeout(active.timer); active.run.status = status; active.run.finishedAt = new Date().toISOString(); if (error)
+        return; clearTimeout(active.timer); if (status !== "succeeded" && active.stdout)
+        active.run.logs = clipped(`${active.run.logs}${active.stdout}`); active.run.status = status; active.run.finishedAt = new Date().toISOString(); if (error)
         active.run.error = error; if (!active.child.killed) {
         try {
             active.child.kill();

package/dist/server/types.d.ts

@@ -98,6 +98,7 @@ export type Message = {
         at: number;
         text: string;
     }[];
+    thinkingActive?: boolean;
     images?: MessageImage[];
     attachments?: MessageAttachments;
     agentIdentity?: {
@@ -203,6 +204,16 @@ export type ToolCallBlock = {
      */
     at?: number;
     thinkingAt?: number;
+    /** Index into the message's thinkingBlocks, captured when this call was first announced.
+     * null means outside reasoning; absence is an older record with offsets only. */
+    thinkingBlock?: number | null;
+    /** A background command keeps its dispatch position and settled output after the active task is removed. */
+    backgroundTask?: {
+        id: string;
+        status: "running" | "completed" | "failed";
+        output?: string;
+        exitCode?: number;
+    };
     question?: ToolCallQuestion;
 };
 /**
@@ -565,6 +576,22 @@ export type SubagentRun = {
      * Absent means `human`, which is what every record written before this field existed was.
      */
     dispatchedBy?: "human" | "model";
+    /**
+     * WHERE THIS RUN WAS ASKED FOR, as a position in the dispatching assistant message: the message id, and
+     * the index of the tool call inside its `toolCalls`.
+     *
+     * This exists because a card anchored to nothing is anchored to a CLOCK. `startedAt` is when the child
+     * was spawned, and the message that dispatched it goes on streaming for seconds afterwards, so sorting
+     * cards against messages by time dropped every card below every message still being written - which is
+     * why sub-agent cards appeared at the bottom of the transcript instead of at the call that asked for
+     * them. Ordering by call position fixes that in the only direction a reader means: later call, later
+     * card, regardless of which child finishes first.
+     *
+     * ABSENT IS NORMAL AND MEANS "no anchor", never "row zero": a person pressing 派子智能体 has no tool
+     * call, and neither does a record written before this field existed. Both render as they always did.
+     */
+    originMessageId?: string;
+    originCallRow?: number;
     /** Authoritative dispatch ancestry, assigned by the server. */
     parentRunId?: string;
     depth: number;
@@ -628,6 +655,11 @@ export type BackgroundTaskSummary = {
     status: "running" | "completed" | "failed";
     startedAt: string;
     resultBlockId: string;
+    /** The same call-position anchor a `SubagentRun` carries, and for the same reason: a background command
+     *  asked for inside a turn belongs at that call, not wherever its output happened to land. Absent when
+     *  the task was not started by a tool call. */
+    originMessageId?: string;
+    originCallRow?: number;
 };
 /**
  * Orchestrated plans, optional for the same reason `todos` is: a `state.json` written before this
@@ -1075,7 +1107,16 @@ export type ServerVersionInfo = {
     latestVersion?: string;
     updateAvailable?: boolean;
 };
+export type MountedToolSummary = {
+    id: string;
+    name: string;
+    description?: string;
+    enabled: boolean;
+};
 export type ServerEvent = {
+    type: "tools.updated";
+    tools: MountedToolSummary[];
+} | {
     type: "operation.result";
     requestId: string;
     ok: boolean;
@@ -1099,6 +1140,7 @@ export type ServerEvent = {
     delta: string;
     active: boolean;
     at?: number;
+    blockIndex?: number;
 }
 /**
  * THE ANSWER TO `conversation.fork`, as ONE event with an `ok` discriminant rather than two events or a

package/dist/server/ws-server.js

@@ -44,13 +44,20 @@ export class WsBroadcaster {
     enqueueStreaming(socket, event) {
         let pending = this.pendingStreams.get(socket);
         if (!pending) {
-            const events = new Map();
+            const events = [];
             pending = { events, timer: setTimeout(() => this.flushStreaming(socket), 16) };
             this.pendingStreams.set(socket, pending);
         }
-        const key = `${event.type}\u0000${event.conversationId}\u0000${event.messageId}`;
-        const previous = pending.events.get(key);
-        pending.events.set(key, previous ? { ...previous, delta: previous.delta + event.delta } : event);
+        // Only adjacent fragments from the same stream can merge. A different kind,
+        // answer offset or lifecycle flag is an ordering boundary, even within 16ms.
+        const previous = pending.events.at(-1);
+        if (previous && previous.type === event.type && previous.conversationId === event.conversationId
+            && previous.messageId === event.messageId && (event.type !== "message.thinking"
+            || (previous.type === "message.thinking" && previous.at === event.at && previous.active === event.active && previous.blockIndex === event.blockIndex))) {
+            pending.events[pending.events.length - 1] = { ...event, delta: previous.delta + event.delta };
+        }
+        else
+            pending.events.push(event);
     }
     getSockets() {
         return this.sockets;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -28,7 +28,7 @@
     "dev:client": "vite --host 0.0.0.0",
     "dev:server": "cross-env SUPER_PI_PORT=3081 tsx watch src/server/index.ts",
     "dev:installed": "npm run build && cross-env SUPER_PI_PORT=3080 node bin/super-pi.js",
-    "build": "tsc -b && vite build",
+    "build": "tsc -b && vite build && node scripts/fresh-build.mjs",
     "start": "node dist/server/index.js",
     "restart:server": "node scripts/restart-server.mjs",
     "smoke": "npm run build && node scripts/smoke.mjs",
@@ -85,6 +85,7 @@
     "scripts/model-filter.test.mjs",
     "scripts/active-memory.test.mjs",
     "scripts/tool-runner.test.mjs",
+    "scripts/tool-runtime-api.test.mjs",
     "scripts/extension-load.test.mjs"
   ],
   "check:browser": [
@@ -104,6 +105,7 @@
     "scripts/md-render-browser.test.mjs",
     "scripts/right-sidebar-browser.test.mjs",
     "scripts/sidebar-tools-browser.test.mjs",
+    "scripts/tool-runtime-browser.test.mjs",
     "scripts/session-context-menu-browser.test.mjs",
     "scripts/tool-call-blocks-browser.test.mjs",
     "scripts/files-tab-browser.test.mjs",