@evandu/super-pi 0.1.89 → 0.1.91

package/dist/server/store.js

@@ -135,7 +135,11 @@ function reconcileConversations(state) {
     state.conversations = conversations;
     const orphaned = [];
     for (const conversation of conversations) {
-        if (!conversation || conversation.status !== "running")
+        // `waiting` joins the orphan set for the same reason `running` does: the turn was opened (a prompt
+        // was sent) and the server died before any settled state was recorded. A conversation that was in
+        // either of those two states when the process went away has a half-open turn whose outcome nobody
+        // can determine from the file alone - exactly the situation this sweep exists to remove.
+        if (!conversation || (conversation.status !== "running" && conversation.status !== "waiting"))
             continue;
         conversation.status = "failed";
         conversation.error = ORPHANED_CONVERSATION_ERROR;
@@ -358,9 +362,16 @@ function reconcileWaitingMessages(state) {
     const recovered = [];
     for (const conversation of state.conversations) {
         for (const message of conversation.messages) {
-            // A `delivery` on anything but a user message is a broken file: no code path writes one, and
-            // rendering a waiting state on an assistant bubble would be a claim about nothing.
-            if (message.role !== "user") {
+            // A `delivery` on an ASSISTANT message is still a broken file: rendering a waiting state on an
+            // assistant bubble would be a claim about nothing, and nothing in the code path writes one. Tool
+            // messages with `delivery` are queue items now (exec / sub-agent background completions) - if they
+            // died in `sending`, recover them to `waiting` just like user messages, so a crashed server does
+            // not strand a 后台回传 whose delivery it had already accepted.
+            if (message.role === "assistant") {
+                delete message.delivery;
+                continue;
+            }
+            if (message.role !== "user" && message.role !== "tool") {
                 delete message.delivery;
                 continue;
             }
@@ -683,10 +694,18 @@ export class Store {
         if (workspace.defaultAgentId)
             conversation.agentId = workspace.defaultAgentId;
         if (configuration) {
-            if (configuration.model)
-                conversation.model = { ...configuration.model };
-            if (configuration.thinkingLevel)
-                conversation.thinkingLevel = configuration.thinkingLevel;
+            if (configuration.model !== undefined) {
+                if (configuration.model)
+                    conversation.model = { ...configuration.model };
+                else
+                    delete conversation.model;
+            }
+            if (configuration.thinkingLevel !== undefined) {
+                if (configuration.thinkingLevel)
+                    conversation.thinkingLevel = configuration.thinkingLevel;
+                else
+                    delete conversation.thinkingLevel;
+            }
             if (configuration.agentId)
                 conversation.agentId = configuration.agentId;
         }
@@ -869,8 +888,13 @@ export class Store {
             : (firstUser?.images?.length ? "【图片】" : DEFAULT_CONVERSATION_TITLE);
         if (!conversation.titleLocked)
             conversation.title = autoTitle || DEFAULT_CONVERSATION_TITLE;
+        // A TURN STARTS IN `waiting`, NOT `running`. The first delta from the model is what flips the
+        // conversation to `running` (see `RunService.streamTurn`); opening a turn only proves a prompt was
+        // sent, and a prompt that was sent but never answered looks identical to one that is mid-stream
+        // until something tells them apart. Holding the gap open is what makes a stuck LLM endpoint
+        // visible to a person - the `waiting` mark on the sidebar row is the only honest signal.
         conversation.updatedAt = message.createdAt;
-        conversation.status = "running";
+        conversation.status = "waiting";
         // The reason this conversation was failed - startup reconciliation's note that a previous run was cut
         // short - describes THAT run, and this line is the moment it stops being the current one. Deleting the
         // key rather than overwriting it keeps the file byte-identical to a conversation that was never
@@ -896,22 +920,26 @@ export class Store {
         return id("message");
     }
     /**
-     * Appends one background-result message to a conversation, without starting a turn.
-     *
-     * Used by sub-agent dispatch completions and the exec service when they finish out of band - the
-     * result is the prompt for a follow-up turn in the old design, which made a "后台回传" render under
-     * the "你" bubble and asked the model to consume a tool envelope as user prose. This appends a
-     * `role: "tool"` message that the client renders with its own column and its own block UI, so the
-     * transcript shows the result AND nothing pretends the user said it.
-     *
-     * NO `turnContext` claim, NO `status: "running"`. The message sits in the transcript and a subsequent
-     * caller can start a turn normally if it wants the model to react to the result.
+     * Appends one background-result message to a conversation. The render column is the same as before
+     * (a `role: "tool"` row, never impersonating a user bubble) - what this method now ALSO supports is
+     * putting the message straight into the dock by passing `delivery: "waiting"`, which is what exec and
+     * sub-agent background completions do once a 后台回传 is treated as a queue item with steer priority
+     * rather than a one-way notice the model never gets to read.
+     *
+     * NO `turnContext` claim, NO `status: "running"`. The message sits in the transcript; with a delivery
+     * state it also enters `waitingMessages` and `runConversationTurns` will pick it up next.
      */
-    async addToolMessage(conversationId, content) {
+    async addToolMessage(conversationId, content, options) {
         const conversation = this.requireConversation(conversationId);
         if (conversation.archivedAt)
             throw new Error("无法向已归档的会话追加后台回传，请先恢复该会话");
-        const message = { id: id("message"), role: "tool", content, createdAt: now() };
+        const message = {
+            id: id("message"),
+            role: "tool",
+            content,
+            createdAt: now(),
+            ...(options?.delivery ? { delivery: options.delivery } : {}),
+        };
         conversation.messages.push(message);
         conversation.updatedAt = message.createdAt;
         await this.persist();
@@ -1358,14 +1386,18 @@ export class Store {
     listWaitingMessages(conversationId) {
         return structuredClone(this.waitingMessages(this.requireConversation(conversationId)));
     }
-    /** The same list by reference, for callers that only read a field and must not pay for a clone. */
+    /** The same list by reference, for callers that only read a field and must not pay for a clone.
+     *
+     * Includes `role: "tool"` messages now that a 后台回传 is a real queue item: same dock, same ordering,
+     * same delivery state machine, same steer/claim semantics - the only thing different is the render
+     * (kept as a 后台回传 block) and what the agent is told when its turn comes (see `composePrompt`). */
     waitingMessages(conversation) {
-        return conversation.messages.filter((message) => message.role === "user" && message.delivery);
+        return conversation.messages.filter((message) => (message.role === "user" || message.role === "tool") && message.delivery);
     }
     requireWaitingMessage(conversationId, messageId) {
         const conversation = this.requireConversation(conversationId);
         const message = conversation.messages.find((item) => item.id === messageId);
-        if (!message || message.role !== "user" || !message.delivery)
+        if (!message || !message.delivery || (message.role !== "user" && message.role !== "tool"))
             throw new Error(`等待中的消息不存在或已被处理：${messageId}`);
         return { conversation, message };
     }
@@ -1410,7 +1442,7 @@ export class Store {
     async markMessageWaiting(conversationId, messageId) {
         const conversation = this.requireConversation(conversationId);
         const message = conversation.messages.find((item) => item.id === messageId);
-        if (!message || message.role !== "user")
+        if (!message || (message.role !== "user" && message.role !== "tool"))
             return undefined;
         if (message.delivery === "sending")
             throw new Error("这条消息已经交给 Agent 了");
@@ -1479,7 +1511,7 @@ export class Store {
         if (index < 0)
             return undefined;
         const message = conversation.messages[index];
-        if (message.role !== "user" || !message.delivery)
+        if ((message.role !== "user" && message.role !== "tool") || !message.delivery)
             return undefined;
         if (message.delivery === "sending")
             throw new Error("这条消息已经交给 Agent 了，取消不掉（Pi 没有撤回单条队列消息的能力）");
@@ -1488,18 +1520,17 @@ export class Store {
         return structuredClone(removed);
     }
     /**
-     * Rewrites the words of one waiting message.
-     *
-     * Only legal while nothing has read it. `waiting` means the text is still only in this transcript, so
-     * changing it is changing the whole truth of the message - there is no second copy anywhere that could
-     * fall out of step. `sending` means Pi already holds it, and a message the model is about to answer is
-     * not one the user gets to rewrite after the fact.
+     * Rewrites the words of one waiting message. User sends only - a 后台回传 carries a `<task>` envelope
+     * the model parses for state, summary and body, and editing it would change a fact the agent has
+     * already started reasoning from. The client dock shows no 「改字」 button for `role: "tool"` rows.
      */
     async editWaitingMessage(conversationId, messageId, content) {
         const trimmed = content.trim();
         if (!trimmed)
             throw new Error("消息不能为空");
         const { conversation, message } = this.requireWaitingMessage(conversationId, messageId);
+        if (message.role === "tool")
+            throw new Error("后台任务结果不能改字");
         if (message.delivery !== "waiting")
             throw new Error("这条消息已经交给 Agent 了，改不了（Pi 已经收到了原文）");
         message.content = trimmed;
@@ -1571,7 +1602,11 @@ export class Store {
      */
     async deliverWaitingMessage(conversationId, agentIdentity) {
         const conversation = this.requireConversation(conversationId);
-        const index = conversation.messages.findIndex((item) => item.role === "user" && item.delivery === "sending");
+        // Looks for the single message Pi is currently answering. A `role: "tool"` 后台回传 that has been
+        // steered or taken is on the same delivery state machine as a user message, so it is the answer
+        // target too; the assistant placeholder still lands directly below it and the role/identity is read
+        // from the conversation (not the message) when the turn opens.
+        const index = conversation.messages.findIndex((item) => (item.role === "user" || item.role === "tool") && item.delivery === "sending");
         if (index < 0)
             return undefined;
         const user = conversation.messages[index];
@@ -1592,9 +1627,10 @@ export class Store {
      * question that is still waiting - a transcript lying about its own order. Splicing at
      * `indexOf(user) + 1` keeps every waiting message below the reply that belongs to the one above it.
      *
-     * The side effects - title, `updatedAt`, `status: "running"`, clearing a stale failure - all describe a
+     * The side effects - title, `updatedAt`, `status: "waiting"`, clearing a stale failure - all describe a
      * TURN rather than a message, which is why `addUserMessage` skips them for a message that is only
-     * waiting. They belong here, at the moment the turn genuinely begins.
+     * waiting. They belong here, at the moment the turn genuinely begins - the model still has not
+     * returned a token, and that is the shape the row carries until `streamTurn` sees the first delta.
      */
     async openTurnOnMessage(conversationId, messageId, agentIdentity) {
         const conversation = this.requireConversation(conversationId);
@@ -1611,8 +1647,10 @@ export class Store {
             : (firstUser?.images?.length ? "【图片】" : DEFAULT_CONVERSATION_TITLE);
         if (!conversation.titleLocked)
             conversation.title = autoTitle || DEFAULT_CONVERSATION_TITLE;
+        // Same `waiting` reasoning as `addUserMessage` above - the prompt was just handed off and no
+        // token has come back yet, which is a different observable state from "we have data flowing".
         conversation.updatedAt = user.createdAt;
-        conversation.status = "running";
+        conversation.status = "waiting";
         delete conversation.error;
         await this.persistMessages(conversation);
         return { user: structuredClone(user), assistant: structuredClone(assistant) };

package/dist/server/types.d.ts

@@ -5,7 +5,19 @@ export type ModelFilterRule = {
     label?: string;
 };
 import type { WorkflowRun } from "./workflow.js";
-export type RunStatus = "idle" | "running" | "completed" | "stopped" | "failed";
+/**
+ * The lifecycle states a `Conversation.status` moves through while a turn is in flight. `waiting` is the
+ * gap between "prompt handed to the LLM" and "the first response token arrived" - holding it apart from
+ * `running` is what lets the reader tell a slow or broken LLM endpoint (still waiting) apart from a
+ * streaming turn that is just slow (already running, just no new tokens in the last second). Without
+ * the gap the two states look the same on screen for as long as the model is silent, and the reader has
+ * no signal to debug from.
+ *
+ * `completed` / `stopped` / `failed` are the three settled states. `stopped` is what `run.stop` lands;
+ * `failed` is what any unhandled throw lands (with `Conversation.error` carrying the translated reason);
+ * `completed` is the clean path.
+ */
+export type RunStatus = "idle" | "waiting" | "running" | "completed" | "stopped" | "failed";
 export type MessageRole = "user" | "assistant" | "tool" | "system";
 /**
  * One message in `state.json`.
@@ -1078,6 +1090,12 @@ export type ClientCommandBody =
     conversationId: string;
     messageId: string;
 }
+/** Stops the active turn, then starts this waiting message as a fresh turn. */
+ | {
+    type: "message.interrupt";
+    conversationId: string;
+    messageId: string;
+}
 /** Starts this waiting message as the next turn, only after the current turn has ended. */
  | {
     type: "message.sendQueued";

package/package.json

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