@evandu/super-pi 0.1.29 → 0.1.31

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-_xNokuGH.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DoUhMucG.css">
+    <script type="module" crossorigin src="/assets/index-Bv8kBXop.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BVsQMo7-.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -166,10 +166,43 @@ export class RunService {
         // counter advanced once per yielded delta is the real position of the call in the answer.
         let spoken = 0;
         const rowByToolCallId = new Map();
+        /**
+         * Rows for calls the model is STILL WRITING, keyed by the contentIndex its toolcall_start named.
+         *
+         * The index is the only handle that exists before the arguments are parsed: the tool's id arrives
+         * with toolcall_end, and the host is told nothing until tool_execution_start. Keeping the index → row
+         * map here rather than in the store is what lets tool_execution_start FILL IN the row the reader is
+         * already looking at, instead of appending a second block for the same call and making one call look
+         * like two.
+         */
+        const preparingRowByIndex = new Map();
+        const onToolPreparing = (call) => {
+            const existing = preparingRowByIndex.get(call.contentIndex);
+            if (existing !== undefined) {
+                if (call.delta)
+                    enqueueTools("a tool call argument", () => this.store.updateToolCall(conversation.id, assistant.id, existing, { live: call.delta }));
+                return;
+            }
+            // No name yet is the normal first token, and it is NOT a reason to wait: the block appearing with an
+            // empty name the instant the model starts writing is what tells the reader anything is happening at
+            // all, and it fills in on the next delta.
+            const at = spoken;
+            enqueueTools("a tool call being prepared", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name || "工具", detail: "正在生成参数…", preparing: true, at }));
+            preparingRowByIndex.set(call.contentIndex, preparingRowByIndex.size);
+        };
         const onToolCall = (call) => {
             if (call.id)
                 rowByToolCallId.set(call.id, rowByToolCallId.size);
             const at = spoken;
+            const prepared = [...preparingRowByIndex.values()].at(-1);
+            // THE CALL THAT IS ALREADY ON SCREEN GETS FILLED IN. Appending here instead would show one call
+            // twice - once as a placeholder, once as the real thing - which reads as the agent calling a tool
+            // it never called.
+            if (prepared !== undefined) {
+                preparingRowByIndex.clear();
+                enqueueTools("a tool call", () => this.store.updateToolCall(conversation.id, assistant.id, prepared, { label: call.name, detail: call.detail, args: call.args, live: "", preparing: false }));
+                return;
+            }
             enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args, at }));
         };
         const onToolUpdate = (call) => {
@@ -193,6 +226,7 @@ export class RunService {
             onPiQueue: (snapshot) => this.onPiQueue(conversation.id, snapshot),
             onUserEntry: (entryId) => this.store.setMessagePiEntryId(conversation.id, userMessageId, entryId),
             onToolCall,
+            onToolPreparing,
             onToolUpdate,
             onToolEnd,
             images,

package/dist/server/runtime.d.ts

@@ -1,6 +1,6 @@
 import { type ChildProcessWithoutNullStreams } from "node:child_process";
 import type { ActiveMemory } from "./active-memory.js";
-import { type AgentDefinition, type Conversation, type ExtensionUiAnswer, type ExtensionUiRequest, type MessageImage, type ModelCatalog, type ModelOption, type ModelSelection, type PiQueueSnapshot, type ToolCallNotice } from "./types.js";
+import { type AgentDefinition, type Conversation, type ExtensionUiAnswer, type ExtensionUiRequest, type MessageImage, type ModelCatalog, type ModelOption, type ModelSelection, type PiQueueSnapshot, type ToolCallNotice, type ToolCallPreparing } from "./types.js";
 /**
  * Who answers Pi's Extension UI questions. The runtime never invents an answer: a blocking method
  * either comes back from `ask`, or it is cancelled. That is the whole point of Pi's third response
@@ -90,6 +90,12 @@ export interface AnswerInput {
      * from a frozen agent.
      */
     onToolUpdate?(call: ToolCallNotice): void;
+    /**
+     * Called as the model BUILDS a tool call, before the host has been told anything about it. It is the
+     * difference between a transcript that is quiet for the seconds an 'edit' takes to write its
+     * replacement text, and one that shows the call arriving.
+     */
+    onToolPreparing?(call: ToolCallPreparing): void;
 }
 /**
  * What Pi answered when a `steer` was written to it, from the `disposition` of that command's response
@@ -273,6 +279,8 @@ export type RpcRecord = {
     assistantMessageEvent?: {
         type?: string;
         delta?: string;
+        contentIndex?: number;
+        partial?: unknown;
         reason?: string;
         message?: {
             role?: string;
@@ -558,7 +566,6 @@ export declare const catalogKey: (selection?: ModelSelection) => string;
  * warning on a path that is genuinely optional rather than a startup crash on a build that skipped it.
  */
 export declare function taskExtensionPath(from?: string): string;
-/** Bridges a Pi session to Super Pi through Pi's documented JSONL RPC protocol. */
 export declare class PiRpcRuntime implements AgentRuntime {
     private readonly sessionDir;
     /**
@@ -696,7 +703,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, onToolCall, onToolUpdate, onToolEnd, images, memoryReview, memorySourceConversationId }: AnswerInput): AsyncIterable<string>;
+    answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, 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

@@ -549,6 +549,16 @@ export function taskExtensionPath(from = import.meta.dirname) {
     return resolve(from, "../../agents/super-pi-task/index.ts");
 }
 /** Bridges a Pi session to Super Pi through Pi's documented JSONL RPC protocol. */
+/**
+ * The tool's name as far as the stream has revealed it so far, or an empty string while the model is
+ * still on the first token. Deliberately NOT a placeholder: a block labelled 「工具」 tells the reader
+ * nothing they cannot already see, whereas one labelled 'edit' one second early is the whole point.
+ */
+function toolNameOf(partial) {
+    const content = partial?.content;
+    const block = Array.isArray(content) ? content.find((item) => item?.type === "toolCall") : undefined;
+    return typeof block?.name === "string" ? block.name : "";
+}
 export class PiRpcRuntime {
     sessionDir;
     agents;
@@ -700,7 +710,7 @@ export class PiRpcRuntime {
             [TASK_CAPABILITY_ENV]: mintCapability(conversationId),
         };
     }
-    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolUpdate, onToolEnd, images, memoryReview, memorySourceConversationId }) {
+    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, images, memoryReview, memorySourceConversationId }) {
         await mkdir(this.sessionDir, { recursive: true });
         // Normalize first: the picker can hand over forward slashes or a trailing separator, and `resolve`
         // turns both into one absolute native path. The directory must exist on disk before spawn - a
@@ -953,11 +963,24 @@ export class PiRpcRuntime {
                     }
                     if (record.type === "message_update") {
                         const event = record.assistantMessageEvent;
-                        // text_delta is the only inner event that drives the visible answer. The rest (thinking,
-                        // tool calls, message_start/end) are consumed here, but still announced once each so an
-                        // event shape this runtime ignores cannot pass unnoticed.
+                        // text_delta is what drives the visible answer, and toolcall_start/delta/end are what make a
+                        // call VISIBLE WHILE IT IS BEING WRITTEN.
+                        //
+                        // Those two used to be dropped here by a comment that named them - "the rest (thinking, tool
+                        // calls, message_start/end) are consumed here". Consuming them was the bug, not the design: an
+                        // `edit` call's arguments ARE the old text and the new text, so the model spends many seconds
+                        // and thousands of tokens emitting them, and for every one of those seconds the screen showed
+                        // nothing at all. A frozen transcript and a slow one look identical from the outside; a block
+                        // that appears the instant the model starts writing its arguments is the difference.
+                        //
+                        // The text is what arrives - `toolcall_delta` is a raw JSON fragment, and parsing it early
+                        // would mean guessing at a document that is not finished. It is handed on as it comes.
                         if (event?.type === "text_delta")
                             yield event.delta ?? "";
+                        else if (event?.type === "toolcall_start" && typeof event.contentIndex === "number")
+                            onToolPreparing?.({ contentIndex: event.contentIndex, name: toolNameOf(event.partial) });
+                        else if (event?.type === "toolcall_delta" && typeof event.contentIndex === "number")
+                            onToolPreparing?.({ contentIndex: event.contentIndex, name: "", ...(typeof event.delta === "string" ? { delta: event.delta } : {}) });
                         else
                             noteUnhandled(`message_update:${JSON.stringify(event?.type ?? "(missing)")}`);
                         continue;

package/dist/server/store.d.ts

@@ -264,8 +264,11 @@ export declare class Store {
      * values a tool can genuinely produce, and treating them as "not reported" would erase a real answer.
      */
     updateToolCall(conversationId: string, messageId: string, index: number, patch: {
+        label?: string;
+        detail?: string;
         args?: ToolCallArg[];
         live?: string;
+        preparing?: boolean;
     }): 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

@@ -947,6 +947,12 @@ 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.label !== undefined)
+            call.label = patch.label;
+        if (patch.detail !== undefined)
+            call.detail = patch.detail;
+        if (patch.preparing !== undefined)
+            call.preparing = patch.preparing;
         if (patch.args !== undefined) {
             const merged = new Map((call.args ?? []).map((arg) => [arg.key, arg]));
             for (const arg of patch.args)

package/dist/server/types.d.ts

@@ -131,6 +131,10 @@ export type ToolCallBlock = {
      * distinction that matters when a reader copies it.
      */
     live?: string;
+    /** The model is still GENERATING this call's arguments. Nothing has reached the host yet, so this is
+     * 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;
     at?: number;
 };
 /**
@@ -164,7 +168,14 @@ export type ToolCallNotice = {
     durationMs?: number;
     result?: ToolResultSummary;
     live?: string;
+    preparing?: boolean;
 };
+/** WHAT THE RUNTIME HANDS A CALLER WHEN THE MODEL STARTS, OR CONTINUES, BUILDING A TOOL CALL. */
+export interface ToolCallPreparing {
+    contentIndex: number;
+    name: string;
+    delta?: string;
+}
 /**
  * `archivedAt` is the whole archive mechanism: a state MARKER, not a move. The conversation object never
  * changes workspace or position, so archiving and restoring are a stamp and a clear of one optional field.

package/package.json

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