@evandu/super-pi 0.1.70 → 0.1.71

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-B0eJbg4U.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CbHwRb22.css">
+    <script type="module" crossorigin src="/assets/index-CpHVxuB1.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CKdlMXJt.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -334,6 +334,32 @@ export class RunService {
         this.extensionUiService.cancelPendingUi(conversation.id, "expired");
         let toolCalls = [];
         let pendingTools = Promise.resolve();
+        // Live events are independent from durable checkpoints. Persisting every token made the stdout
+        // reader wait for one disk transaction per token; over a remote browser connection that backlog
+        // looked exactly like a slow model. Keep the in-memory transcript current, publish immediately, and
+        // checkpoint at most once per short window plus unconditionally at the end of the turn.
+        let checkpointTimer;
+        let checkpointPending = false;
+        const checkpointNow = () => {
+            if (checkpointTimer !== undefined) {
+                clearTimeout(checkpointTimer);
+                checkpointTimer = undefined;
+            }
+            if (!checkpointPending)
+                return;
+            checkpointPending = false;
+            // Tool updates and message checkpoints both replace the persisted message. They share this lane
+            // so an earlier text snapshot cannot commit after a newer tool state and erase it on disk.
+            pendingTools = pendingTools.then(() => this.store.checkpointMessage(conversation.id, assistant.id)).catch((error) => {
+                console.warn(`Super Pi: streaming checkpoint failed: ${error instanceof Error ? error.message : "unknown error"}`);
+            });
+        };
+        const scheduleCheckpoint = () => {
+            checkpointPending = true;
+            if (checkpointTimer !== undefined)
+                return;
+            checkpointTimer = setTimeout(checkpointNow, 50);
+        };
         const enqueueTools = (what, work) => {
             pendingTools = pendingTools.then(async () => {
                 toolCalls = await work();
@@ -387,9 +413,11 @@ export class RunService {
             if (existing !== undefined) {
                 // The line naming the call IMPROVES as the arguments arrive - a `read` learns its path from the
                 // first fragment - so it is patched rather than frozen at whatever the first frame could say. The
-                // fragment is stored as well, because that is what the reader watches grow.
-                if (call.delta)
-                    enqueueTools("a tool call argument", () => this.store.updateToolCall(conversation.id, assistant.id, existing.row, { live: call.delta, ...(call.detail ? { detail: call.detail } : {}) }));
+                // text is patched as well, and it is the WHOLE text written so far rather than the newest
+                // fragment: it is the same field the execution output later lands in, and the reader watches it
+                // grow in one piece either way.
+                if (call.live)
+                    enqueueTools("a tool call argument", () => this.store.updateToolCall(conversation.id, assistant.id, existing.row, { live: call.live, ...(call.detail ? { detail: call.detail } : {}) }));
                 return;
             }
             // No name yet is the normal first token, and it is NOT a reason to wait: the block appearing with an
@@ -397,6 +425,13 @@ export class RunService {
             // all, and it fills in on the next delta.
             const at = spoken;
             const row = rows++;
+            // THE OFFSET IS TAKEN NOW, NOT WHEN THE QUEUED APPEND RUNS. `thought` is the LIVE counter, and the
+            // append below runs when the enqueue chain drains - by which time it may already hold the whole
+            // turn's reasoning, so a call made during reasoning would anchor at the END of the text it was made
+            // inside of and render outside the thinking block. `at` above is captured for exactly this reason;
+            // this one was not, and the JSON persistence backend's slower writes widen the window enough for
+            // the browser test to catch the difference between capturing and reading.
+            const thinkingAt = thought;
             // The block says WHICH TOOL and WHAT IT IS AIMED AT as soon as either is known. 「工具」 as the name
             // and 「正在生成参数…」 as the only line below it told a reader nothing for the seconds a large `edit`
             // spends writing its replacement text - and by the time the file path was on screen, the block looked
@@ -407,7 +442,7 @@ export class RunService {
                 ...(call.detail ? { detail: call.detail } : { detail: "正在生成参数…" }),
                 preparing: true,
                 at,
-                thinkingAt: thought,
+                thinkingAt,
             }));
             preparingRows.set(call.contentIndex, { row, name: call.name });
         };
@@ -439,7 +474,10 @@ 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, thinkingAt: thought, ...(call.question ? { question: call.question } : {}) }));
+            // Captured for the same reason as the preparing path above: the queued append must anchor the call
+            // where it was MADE, not where the queue happened to be when it drained.
+            const thinkingAt = thought;
+            enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args, at, thinkingAt, ...(call.question ? { question: call.question } : {}) }));
         };
         const onToolUpdate = (call) => {
             const index = call.id ? rowByToolCallId.get(call.id) : undefined;
@@ -453,33 +491,47 @@ export class RunService {
                 return;
             enqueueTools("a tool call outcome", () => this.store.settleToolCall(conversation.id, assistant.id, index, { status: call.status, durationMs: call.durationMs, ...(call.result ? { result: call.result } : {}) }));
         };
-        for await (const delta of this.runtime.answer({
-            conversation,
-            prompt,
-            signal: controller.signal,
-            cwd: workspace.path,
-            host: this.extensionUiService.createHost(conversation.id),
-            onPiQueue: (snapshot) => this.onPiQueue(conversation.id, snapshot),
-            onUserEntry: (entryId) => this.store.setMessagePiEntryId(conversation.id, userMessageId, entryId),
-            onToolCall,
-            onToolPreparing,
-            onToolUpdate,
-            onToolEnd,
-            // 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);
-            spoken += delta.length;
-            this.broadcaster.broadcast({ type: "message.delta", conversationId: conversation.id, messageId: assistant.id, delta });
+        try {
+            for await (const delta of this.runtime.answer({
+                conversation,
+                prompt,
+                signal: controller.signal,
+                cwd: workspace.path,
+                host: this.extensionUiService.createHost(conversation.id),
+                onPiQueue: (snapshot) => this.onPiQueue(conversation.id, snapshot),
+                onUserEntry: (entryId) => this.store.setMessagePiEntryId(conversation.id, userMessageId, entryId),
+                onSessionFile: (path) => this.store.setConversationPiSessionFile(conversation.id, path),
+                onToolCall,
+                onToolPreparing,
+                onToolUpdate,
+                onToolEnd,
+                // 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.store.appendThinkingDeltaLive(conversation.id, assistant.id, delta);
+                    this.broadcaster.broadcast({ type: "message.thinking", conversationId: conversation.id, messageId: assistant.id, delta, active: true });
+                    scheduleCheckpoint();
+                },
+                images,
+            })) {
+                this.store.appendAssistantDeltaLive(conversation.id, assistant.id, delta);
+                spoken += delta.length;
+                // Tool events are structural transcript boundaries. Publish any boundary Pi announced before
+                // this text before publishing the text itself; this is a handful of writes per call, never one
+                // write per token, and preserves the event order a reconnecting client reconstructs.
+                await pendingTools;
+                this.broadcaster.broadcast({ type: "message.delta", conversationId: conversation.id, messageId: assistant.id, delta });
+                scheduleCheckpoint();
+            }
+        }
+        finally {
+            // A failed or cancelled producer still owns live text and a checkpoint timer.
+            // Drain the lane before the caller changes status or permits another turn.
+            checkpointNow();
+            await pendingTools;
         }
-        await pendingTools;
         if (!controller.signal.aborted) {
             const completed = this.store.snapshot().conversations.find(c => c.id === conversation.id);
             if (completed)

package/dist/server/rpc-channel.d.ts

@@ -0,0 +1,109 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+/** Open-ended Pi RPC record; consumers validate fields before use. */
+export type RpcRecord = {
+    type?: string;
+    id?: string;
+    success?: boolean;
+    error?: string;
+    /** Every `response` record's payload. Kept opaque: only the catalog reader knows these shapes. */
+    data?: unknown;
+    /**
+     * `tool_execution_end` carries the tool's OUTPUT. Declared so it can be REDUCED by
+     * extractToolResultText and then dropped: the raw object must never travel past this record, and that
+     * reduction is the whole reason the result is safe to persist. Kept opaque for the same reason `data` is.
+     */
+    result?: unknown;
+    /** The tool_execution_update record's running output. Reduced by the same function as `result`, never carried raw. */
+    partialResult?: unknown;
+    /**
+     * The inner event of a `message_update`. `message` rides on `done` - the authoritative final
+     * assistant message, with its text content, its stop reason and its model (pi-ai AssistantMessageEvent).
+     */
+    assistantMessageEvent?: {
+        type?: string;
+        delta?: string;
+        contentIndex?: number;
+        partial?: unknown;
+        reason?: string;
+        message?: {
+            role?: string;
+            content?: unknown;
+            stopReason?: string;
+            model?: string;
+        };
+    };
+    /**
+     * Cumulative usage of the CURRENT assistant message, repeated on every one of that message's updates
+     * (modes/json-event.ts:56-59). Reading it anywhere but on `done` counts the same tokens per token.
+     */
+    usage?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        cost?: {
+            total?: number;
+        };
+    };
+    toolCallId?: string;
+    toolName?: string;
+    args?: unknown;
+    /**
+     * tool_execution_end payload. `result` is NOT declared: it is deliberately never read, because for a
+     * `read` it is the file's contents and this type is the one place a reader would reach for it. The two
+     * numbers below are the whole of what a human-readable tool row can honestly report.
+     */
+    isError?: boolean;
+    durationMs?: number;
+    method?: string;
+    title?: string;
+    options?: unknown;
+    message?: string;
+    placeholder?: string;
+    prefill?: string;
+    timeout?: number;
+    notifyType?: string;
+    statusKey?: string;
+    statusText?: string;
+    widgetKey?: string;
+    widgetLines?: unknown;
+    widgetPlacement?: string;
+    text?: string;
+    extensionPath?: string;
+    event?: string;
+    steering?: unknown;
+    followUp?: unknown;
+};
+/** One Pi child, its stdout reader, and the single writer to its stdin. */
+export declare class RpcChannel {
+    private readonly child;
+    private readonly records;
+    /** See `stash`: a drain loop must not discard another command's response. */
+    private readonly stashed;
+    private readonly waiters;
+    private buffer;
+    private exited;
+    private exitReason;
+    /** stderr is kept only to explain an early exit; a well-behaved Pi writes nothing here. */
+    stderr: string;
+    constructor(child: ChildProcessWithoutNullStreams);
+    get exitCode(): number | null;
+    get closed(): boolean;
+    private wake;
+    /** Waits for stdout or process exit without adding a fixed polling delay to every record. */
+    private changed;
+    /** Writes one JSONL command. Throws rather than silently dropping: a command Pi never sees is a lie the caller would act on. */
+    write(command: object): void;
+    /** Returns a response to its waiter after the drain loop encountered it. */
+    stash(record: RpcRecord): void;
+    /** Removes and returns the next record, or undefined after `timeoutMs` with nothing to read. */
+    next(timeoutMs?: number): Promise<RpcRecord | undefined>;
+    /** Sends a command and waits for its response. For one command; use write()+waitFor() to overlap several. */
+    request(command: {
+        id: string;
+        type: string;
+    } & Record<string, unknown>, timeoutMs: number): Promise<RpcRecord>;
+    private take;
+    /** Waits for one correlated response while leaving every unrelated record in order. */
+    waitFor(id: string, timeoutMs: number, what?: string): Promise<RpcRecord>;
+}

package/dist/server/rpc-channel.js

@@ -0,0 +1,117 @@
+/** One Pi child, its stdout reader, and the single writer to its stdin. */
+export class RpcChannel {
+    child;
+    records = [];
+    /** See `stash`: a drain loop must not discard another command's response. */
+    stashed = new Map();
+    waiters = new Set();
+    buffer = "";
+    exited = false;
+    exitReason = "";
+    /** stderr is kept only to explain an early exit; a well-behaved Pi writes nothing here. */
+    stderr = "";
+    constructor(child) {
+        this.child = child;
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => { this.stderr += chunk.toString(); });
+        child.stdout.on("data", (chunk) => {
+            this.buffer += chunk.toString("utf8");
+            let changed = false;
+            let newline;
+            while ((newline = this.buffer.indexOf("\n")) >= 0) {
+                const line = this.buffer.slice(0, newline).replace(/\r$/, "");
+                this.buffer = this.buffer.slice(newline + 1);
+                if (!line)
+                    continue;
+                try {
+                    this.records.push(JSON.parse(line));
+                    changed = true;
+                }
+                catch { /* Pi stdout must be JSONL */ }
+            }
+            if (changed)
+                this.wake();
+        });
+        child.once("exit", (code, signal) => {
+            this.exited = true;
+            this.exitReason = signal ? `signal ${signal}` : `code ${code}`;
+            this.wake();
+        });
+        child.once("error", (error) => {
+            this.exited = true;
+            this.exitReason = error.message;
+            this.wake();
+        });
+    }
+    get exitCode() { return this.child.exitCode; }
+    get closed() { return this.exited || this.child.exitCode !== null; }
+    wake() {
+        for (const resolve of this.waiters)
+            resolve();
+        this.waiters.clear();
+    }
+    /** Waits for stdout or process exit without adding a fixed polling delay to every record. */
+    changed(timeoutMs) {
+        if (timeoutMs <= 0)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            const finish = () => { clearTimeout(timer); this.waiters.delete(finish); resolve(); };
+            const timer = setTimeout(finish, timeoutMs);
+            this.waiters.add(finish);
+        });
+    }
+    /** Writes one JSONL command. Throws rather than silently dropping: a command Pi never sees is a lie the caller would act on. */
+    write(command) {
+        if (this.child.killed || this.child.stdin.destroyed)
+            throw new Error(`Pi RPC stdin is closed, so ${JSON.stringify(command)} was not sent`);
+        this.child.stdin.write(`${JSON.stringify(command)}\n`);
+    }
+    /** Returns a response to its waiter after the drain loop encountered it. */
+    stash(record) {
+        if (record.type === "response" && typeof record.id === "string") {
+            this.stashed.set(record.id, record);
+            this.wake();
+        }
+    }
+    /** Removes and returns the next record, or undefined after `timeoutMs` with nothing to read. */
+    async next(timeoutMs = 100) {
+        const deadline = performance.now() + timeoutMs;
+        for (;;) {
+            if (this.records.length)
+                return this.records.shift();
+            if (this.exited || this.child.exitCode !== null || performance.now() >= deadline)
+                return undefined;
+            await this.changed(deadline - performance.now());
+        }
+    }
+    /** Sends a command and waits for its response. For one command; use write()+waitFor() to overlap several. */
+    async request(command, timeoutMs) {
+        this.write(command);
+        return this.waitFor(command.id, timeoutMs, command.type);
+    }
+    take(id) {
+        const index = this.records.findIndex((record) => record.type === "response" && record.id === id);
+        if (index >= 0)
+            return this.records.splice(index, 1)[0];
+        const stashed = this.stashed.get(id);
+        if (!stashed)
+            return undefined;
+        this.stashed.delete(id);
+        return stashed;
+    }
+    /** Waits for one correlated response while leaving every unrelated record in order. */
+    async waitFor(id, timeoutMs, what = id) {
+        const deadline = performance.now() + timeoutMs;
+        for (;;) {
+            const record = this.take(id);
+            if (record)
+                return record;
+            if (this.exited || this.child.exitCode !== null)
+                throw new Error(`Pi RPC exited (${this.exitReason || `code ${this.child.exitCode}`}) while waiting for ${what}. ${this.stderr.trim()}`);
+            if (performance.now() >= deadline)
+                throw new Error(`Pi did not answer ${what} within ${timeoutMs}ms`);
+            await this.changed(deadline - performance.now());
+        }
+    }
+}