@evandu/super-pi 0.1.135 → 0.1.137

package/dist/server/http-server.js

@@ -230,6 +230,47 @@ function abortedAs(request) {
 /**
  * Creates the HTTP server providing static client assets and all `/api/*` endpoints.
  */
+/**
+ * A REQUEST BODY BEING READ AS TEXT, decoded across chunk boundaries.
+ *
+ * The counterpart of `readRequestText` for the sites that need to inspect the body WHILE it streams
+ * (the file uploads, which refuse an oversized body without reading the rest of it).
+ */
+function textBodyReader() {
+    const decoder = new TextDecoder("utf-8");
+    let text = "";
+    return {
+        push: (chunk) => { text += decoder.decode(chunk, { stream: true }); return text; },
+        finish: () => text + decoder.decode(),
+    };
+}
+/**
+ * THE REQUEST BODY AS TEXT, DECODED ACROSS CHUNK BOUNDARIES.
+ *
+ * `raw += chunk` decodes EVERY CHUNK ON ITS OWN: the chunk is a Buffer, and concatenating it into a
+ * string calls `toString("utf8")` on it. A UTF-8 character that straddles two chunks is then two
+ * half-characters, and each half decodes to U+FFFD - the replacement character. So a Chinese
+ * sentence that happens to be split in the wrong place is silently corrupted, and the corrupted text
+ * is what the endpoint PERSISTS (a knowledge note, a memory, a scheduled task). The corruption is
+ * invisible - the JSON still parses - and permanent.
+ *
+ * A `TextDecoder` in streaming mode keeps the incomplete tail of a chunk and completes it with the
+ * next one, which is what "the body is one UTF-8 document" means. The size guards count BYTES, which
+ * is what a body limit is about anyway.
+ */
+async function readRequestText(request, limitBytes) {
+    const decoder = new TextDecoder("utf-8");
+    let text = "";
+    let bytes = 0;
+    for await (const chunk of request) {
+        const piece = chunk;
+        bytes += piece.length;
+        if (bytes > limitBytes)
+            return { text: "", tooLarge: true };
+        text += decoder.decode(piece, { stream: true });
+    }
+    return { text: text + decoder.decode(), tooLarge: false };
+}
 export function createHttpServer(options) {
     const { context, onShutdown } = options;
     const { store, paths, accessToken, broadcaster, runService, catalogService, execService, toolRegistry, toolRunner } = context;
@@ -320,16 +361,12 @@ export function createHttpServer(options) {
                 // BYTES, NOT CHARACTERS, AND FROM THE REGISTRY'S OWN CONSTANT. The old cap counted UTF-16 code
                 // units at 256,000, below the registry's own 512,000-byte asset limit, so JSON escaping decided
                 // where the real ceiling was and an exported bundle could be refused on the way back in.
-                let raw = "", bytes = 0;
-                for await (const chunk of request) {
-                    const piece = chunk;
-                    bytes += piece.length;
-                    if (bytes > MAX_TOOL_BODY_BYTES) {
-                        json(413, { error: "导入的内容太大，超过了大小上限。" });
-                        return;
-                    }
-                    raw += piece.toString("utf8");
+                const imported = await readRequestText(request, MAX_TOOL_BODY_BYTES);
+                if (imported.tooLarge) {
+                    json(413, { error: "导入的内容太大，超过了大小上限。" });
+                    return;
                 }
+                const raw = imported.text;
                 const body = JSON.parse(raw);
                 if (!isAuthorized(request, accessToken)) {
                     if (!body.conversationId) {
@@ -404,14 +441,12 @@ export function createHttpServer(options) {
                     toolApi(405, { error: "method" });
                     return;
                 }
-                let raw = "";
-                for await (const chunk of request) {
-                    raw += chunk;
-                    if (raw.length > 64_000) {
-                        toolApi(413, { error: "request too large" });
-                        return;
-                    }
+                const executed = await readRequestText(request, 64_000);
+                if (executed.tooLarge) {
+                    toolApi(413, { error: "request too large" });
+                    return;
                 }
+                const raw = executed.text;
                 try {
                     const body = JSON.parse(raw);
                     const resolved = await toolRegistry.resolve(id);
@@ -501,14 +536,12 @@ export function createHttpServer(options) {
                         toolApi(405, { error: "method" });
                         return;
                     }
-                    let raw = "";
-                    for await (const chunk of request) {
-                        raw += chunk;
-                        if (raw.length > 64_000) {
-                            toolApi(413, { error: "request too large" });
-                            return;
-                        }
+                    const asked = await readRequestText(request, 64_000);
+                    if (asked.tooLarge) {
+                        toolApi(413, { error: "request too large" });
+                        return;
                     }
+                    const raw = asked.text;
                     try {
                         const body = JSON.parse(raw);
                         toolApi(202, context.toolLlm.start({ toolId: id, prompt: body.prompt ?? "", system: body.system, timeoutMs: body.timeoutMs }));
@@ -598,14 +631,10 @@ export function createHttpServer(options) {
                 return;
             }
             try {
-                let raw = "";
-                let totalBytes = 0;
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > 512000)
-                        throw new Error("记忆请求过大");
-                    raw += chunk;
-                }
+                const remembered = await readRequestText(request, 512000);
+                if (remembered.tooLarge)
+                    throw new Error("记忆请求过大");
+                const raw = remembered.text;
                 const body = raw ? JSON.parse(raw) : {};
                 const result = url.pathname.endsWith("/tool")
                     ? await context.memory.tool(String(request.headers["x-memory-capability"] ?? ""), body)
@@ -634,9 +663,10 @@ export function createHttpServer(options) {
             let name = url.searchParams.get("name") ?? url.searchParams.get("skillId") ?? "";
             if (request.method === "POST") {
                 try {
-                    let raw = "";
-                    for await (const chunk of request)
-                        raw += chunk;
+                    const asked = await readRequestText(request, 512000);
+                    if (asked.tooLarge)
+                        throw new Error("记忆请求过大");
+                    const raw = asked.text;
                     if (raw) {
                         const body = JSON.parse(raw);
                         if (body.workspaceId)
@@ -673,9 +703,12 @@ export function createHttpServer(options) {
                 return;
             }
             try {
-                let raw = "";
-                for await (const chunk of request)
-                    raw += chunk;
+                const asked = await readRequestText(request, 512000);
+                if (asked.tooLarge) {
+                    json(413, { error: "请求过大" });
+                    return;
+                }
+                const raw = asked.text;
                 const body = raw ? JSON.parse(raw) : {};
                 const models = await context.providerService.fetchModels(body);
                 json(200, { ok: true, models });
@@ -704,14 +737,12 @@ export function createHttpServer(options) {
                 let totalBytes = 0;
                 // A pasted document rides in the body, so the cap is the document cap - past it the request is
                 // refused outright rather than truncated into a document that silently lost its tail.
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > MAX_KNOWLEDGE_REQUEST_BYTES) {
-                        response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "知识库请求过大" }));
-                        return;
-                    }
-                    raw += chunk;
+                const known = await readRequestText(request, MAX_KNOWLEDGE_REQUEST_BYTES);
+                if (known.tooLarge) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "知识库请求过大" }));
+                    return;
                 }
+                raw = known.text;
                 const body = raw ? JSON.parse(raw) : {};
                 const result = url.pathname.endsWith("/tool")
                     ? await context.knowledge.tool(String(request.headers["x-knowledge-capability"] ?? ""), body, abortedAs(request))
@@ -743,14 +774,12 @@ export function createHttpServer(options) {
                 // A DOCUMENT'S TEXT RIDES IN THE REQUEST BODY, so the cap is the document cap: a request
                 // past it is refused outright rather than truncated into a document that silently lost its
                 // tail.
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > MAX_DOCUMENT_REQUEST_BYTES) {
-                        response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "文档请求过大" }));
-                        return;
-                    }
-                    raw += chunk;
+                const documented = await readRequestText(request, MAX_DOCUMENT_REQUEST_BYTES);
+                if (documented.tooLarge) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "文档请求过大" }));
+                    return;
                 }
+                raw = documented.text;
                 const body = raw ? JSON.parse(raw) : {};
                 // The capability says WHICH CONVERSATION is asking, and the workspace is derived from it
                 // rather than taken from the request: a request that named its own workspace would be a
@@ -787,14 +816,12 @@ export function createHttpServer(options) {
             }
             try {
                 let raw = "", totalBytes = 0;
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > MAX_WEB_REQUEST_BYTES) {
-                        response.writeHead(413).end();
-                        return;
-                    }
-                    raw += chunk;
+                const asked = await readRequestText(request, MAX_WEB_REQUEST_BYTES);
+                if (asked.tooLarge) {
+                    response.writeHead(413).end();
+                    return;
                 }
+                raw = asked.text;
                 const conversationId = String(request.headers["x-web-conversation"] ?? "");
                 const verdict = verifyCapability(conversationId, request.headers["x-web-capability"], { running: context.runService.isRunning(conversationId) });
                 if (!verdict.ok) {
@@ -831,14 +858,12 @@ export function createHttpServer(options) {
             try {
                 let raw = "", totalBytes = 0;
                 // The Markdown of a document rides in the request body, so the cap is the document cap.
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > MAX_FEISHU_REQUEST_BYTES) {
-                        response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "飞书请求过大" }));
-                        return;
-                    }
-                    raw += chunk;
+                const asked = await readRequestText(request, MAX_FEISHU_REQUEST_BYTES);
+                if (asked.tooLarge) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "飞书请求过大" }));
+                    return;
                 }
+                raw = asked.text;
                 const conversationId = String(request.headers["x-feishu-conversation"] ?? "");
                 // THE SAME PROOF THE DOCUMENT TOOLS USE: the request must carry the session's own
                 // capability, and the session must actually be running a turn. The Feishu credential is a
@@ -1050,9 +1075,12 @@ export function createHttpServer(options) {
                         json(403, { error: "Git 写操作只允许来自本机或局域网的请求。" });
                         return;
                     }
-                    let raw = "";
-                    for await (const chunk of request)
-                        raw += chunk;
+                    const asked = await readRequestText(request, 512000);
+                    if (asked.tooLarge) {
+                        json(413, { error: "请求过大" });
+                        return;
+                    }
+                    const raw = asked.text;
                     const body = raw ? JSON.parse(raw) : {};
                     json(200, await gitMutate(workspace.path, op, body.path, body.message));
                     return;
@@ -1113,15 +1141,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1151,15 +1182,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1234,15 +1268,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1262,15 +1299,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1303,15 +1343,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1407,14 +1450,12 @@ export function createHttpServer(options) {
             // body cost its full size in memory before the 403 said no. A question is a few hundred bytes;
             // 64KB is orders of magnitude above any honest one and far below what a hostile body could use,
             // and the shape is the same ceiling the `/api/tools` endpoints already enforce.
-            let raw = "";
-            for await (const chunk of request) {
-                raw += chunk;
-                if (raw.length > 64_000) {
-                    response.writeHead(413, { "content-type": "application/json" }).end(JSON.stringify({ error: "question request too large" }));
-                    return;
-                }
+            const asked = await readRequestText(request, 64_000);
+            if (asked.tooLarge) {
+                response.writeHead(413, { "content-type": "application/json" }).end(JSON.stringify({ error: "question request too large" }));
+                return;
             }
+            const raw = asked.text;
             try {
                 const body = JSON.parse(raw);
                 if (!body.conversationId || !body.question || !Array.isArray(body.options))
@@ -1633,15 +1674,18 @@ export function createHttpServer(options) {
                     }
                     let raw = "";
                     let totalBytes = 0;
+                    const reader = textBodyReader();
                     for await (const chunk of request) {
-                        totalBytes += chunk.length;
+                        const piece = chunk;
+                        totalBytes += piece.length;
                         if (totalBytes > MAX_FILE_BYTES * 2) {
                             json(413, { error: "请求体过大", code: "too_large" });
                             request.destroy();
                             return;
                         }
-                        raw += chunk;
+                        raw = reader.push(piece);
                     }
+                    raw = reader.finish();
                     const declared = Number(request.headers["content-length"] ?? "0");
                     if (Number.isFinite(declared) && declared > MAX_FILE_BYTES * 2) {
                         json(413, { error: "请求体过大", code: "too_large" });

package/dist/server/model-filter.d.ts

@@ -6,8 +6,18 @@ export declare function applicableRules(rules: ModelFilterRule[] | undefined, wo
 export declare function assertModelAllowed(rules: ModelFilterRule[] | undefined, workspace: Workspace, model: ModelSelection | undefined): void;
 export declare function conversationWorkspace(state: AppState, conversationId: string): Workspace;
 /** Resolve Pi's actual global default when no model was selected; never guess a permitted replacement. */
-export declare function validateConversationModel(store: {
-    snapshot(): AppState;
-}, runtime: {
+/**
+ * THE STORE READS THIS NEEDS, AND NOTHING ELSE.
+ *
+ * The check wants two things: the rules, and the workspace the conversation is in. Both now have a
+ * narrow reader on the store (`modelFilterRules()` / `workspaceForConversation()`), so this path
+ * clones NOTHING - it used to deep-clone the whole application three times over, on the way to
+ * sending a message.
+ */
+export interface ModelFilterStore {
+    modelFilterRules(): import("./types.js").ModelFilterRule[];
+    workspaceForConversation(conversationId: string): Workspace | undefined;
+}
+export declare function validateConversationModel(store: ModelFilterStore, runtime: {
     catalog(selection?: ModelSelection): Promise<import("./types.js").ModelCatalog>;
 }, conversationId: string, selection?: ModelSelection): Promise<void>;

package/dist/server/model-filter.js

@@ -29,18 +29,20 @@ export function conversationWorkspace(state, conversationId) {
         throw new Error("会话所属工作区不存在");
     return workspace;
 }
-/** Resolve Pi's actual global default when no model was selected; never guess a permitted replacement. */
 export async function validateConversationModel(store, runtime, conversationId, selection) {
-    const state = store.snapshot();
-    const workspace = conversationWorkspace(state, conversationId);
-    if (!applicableRules(state.modelFilterRules, workspace).length)
+    const workspace = store.workspaceForConversation(conversationId);
+    if (!workspace)
+        throw new Error("会话所属工作区不存在");
+    if (!applicableRules(store.modelFilterRules(), workspace).length)
         return;
     const startedAt = performance.now();
     if (process.env.SUPER_PI_TRACE_LATENCY === "1")
         console.warn(`[super-pi latency] conversation=${conversationId} phase=model.validate.begin selection=${selection ? `${selection.provider}/${selection.modelId}` : "default"}`);
     const catalog = await runtime.catalog();
     const model = selection ? catalog.models.find(item => item.provider === selection.provider && item.modelId === selection.modelId) ?? selection : catalog.defaultModel;
-    assertModelAllowed(store.snapshot().modelFilterRules, conversationWorkspace(store.snapshot(), conversationId), model);
+    // READ AGAIN, NOT CACHED: the catalog fetch above is an await, and a rule edited during it must
+    // still be enforced for this message. The narrow readers make that re-read cheap.
+    assertModelAllowed(store.modelFilterRules(), store.workspaceForConversation(conversationId), model);
     if (process.env.SUPER_PI_TRACE_LATENCY === "1")
         console.warn(`[super-pi latency] conversation=${conversationId} phase=model.validate.end elapsedMs=${Math.round(performance.now() - startedAt)}`);
 }

package/dist/server/store.d.ts

@@ -96,6 +96,33 @@ export declare class Store {
     static open(filePath: string): Promise<Store>;
     /** Opens an injected repository, retaining domain reconciliation here. */
     static openRepository(repository: AppStateRepository): Promise<Store>;
+    /**
+     * THE MODEL FILTER RULES, WITHOUT CLONING THE STATE TO READ THEM.
+     *
+     * `snapshot()` deep-clones the WHOLE application - every workspace, every conversation, every
+     * message of every conversation - and the model filter check needs ONE small array. Reading that
+     * array through a full clone is the difference between a few hundred bytes and the entire
+     * transcript of the app, on the path that runs every time a message is sent.
+     *
+     * So the rules get their own narrow reader. It returns a COPY of the array (the caller may keep
+     * it, and the store's own state must not change under it), and the individual rules are treated
+     * as read-only - which is what the filter does with them.
+     */
+    modelFilterRules(): import("./types.js").ModelFilterRule[];
+    /**
+     * THE WORKSPACE A CONVERSATION BELONGS TO, WITHOUT CLONING THE STATE TO FIND ONE ROW.
+     *
+     * The same argument as the rules above: the filter needs to know WHICH workspace the conversation
+     * is in (the rules are per workspace), and the only way to know that today is to clone everything
+     * and look. This returns a shallow copy of the one workspace - cheap, and detached enough that a
+     * caller cannot reach into the store's state through it.
+     */
+    workspaceForConversation(conversationId: string): Workspace | undefined;
+    workspace(workspaceId: string): Workspace | undefined;
+    /** Small detached rows used when refreshing each conversation's scoped model catalog. */
+    catalogConversationTargets(): Array<Pick<Conversation, "id" | "archivedAt" | "model">>;
+    /** Clone only one workspace's transcripts, never unrelated workspaces or app state. */
+    conversationsForWorkspace(workspaceId: string): Conversation[];
     setModelFilterRules(rules: import("./types.js").ModelFilterRule[]): Promise<void>;
     /**
      * Sets (or clears) the app-wide default model.

package/dist/server/store.js

@@ -689,6 +689,50 @@ export class Store {
             return new Store(repository, { workspaces: [], conversations: [], subagentRuns: [], backgroundTasks: [] });
         }
     }
+    /**
+     * THE MODEL FILTER RULES, WITHOUT CLONING THE STATE TO READ THEM.
+     *
+     * `snapshot()` deep-clones the WHOLE application - every workspace, every conversation, every
+     * message of every conversation - and the model filter check needs ONE small array. Reading that
+     * array through a full clone is the difference between a few hundred bytes and the entire
+     * transcript of the app, on the path that runs every time a message is sent.
+     *
+     * So the rules get their own narrow reader. It returns a COPY of the array (the caller may keep
+     * it, and the store's own state must not change under it), and the individual rules are treated
+     * as read-only - which is what the filter does with them.
+     */
+    modelFilterRules() {
+        return this.state.modelFilterRules ? [...this.state.modelFilterRules] : [];
+    }
+    /**
+     * THE WORKSPACE A CONVERSATION BELONGS TO, WITHOUT CLONING THE STATE TO FIND ONE ROW.
+     *
+     * The same argument as the rules above: the filter needs to know WHICH workspace the conversation
+     * is in (the rules are per workspace), and the only way to know that today is to clone everything
+     * and look. This returns a shallow copy of the one workspace - cheap, and detached enough that a
+     * caller cannot reach into the store's state through it.
+     */
+    workspaceForConversation(conversationId) {
+        const conversation = this.state.conversations.find((item) => item.id === conversationId);
+        const workspace = this.state.workspaces.find((item) => item.id === conversation?.workspaceId);
+        return workspace ? { ...workspace } : undefined;
+    }
+    workspace(workspaceId) {
+        const workspace = this.state.workspaces.find((item) => item.id === workspaceId);
+        return workspace ? { ...workspace } : undefined;
+    }
+    /** Small detached rows used when refreshing each conversation's scoped model catalog. */
+    catalogConversationTargets() {
+        return this.state.conversations.map(({ id, archivedAt, model }) => ({
+            id,
+            archivedAt,
+            model: model ? { ...model } : undefined,
+        }));
+    }
+    /** Clone only one workspace's transcripts, never unrelated workspaces or app state. */
+    conversationsForWorkspace(workspaceId) {
+        return structuredClone(this.state.conversations.filter((item) => item.workspaceId === workspaceId));
+    }
     async setModelFilterRules(rules) {
         if (!Array.isArray(rules) || rules.some(rule => !rule || typeof rule.id !== "string" || typeof rule.workspacePattern !== "string" || typeof rule.modelPattern !== "string" || (rule.label !== undefined && typeof rule.label !== "string")))
             throw new Error("模型过滤规则格式不合法");

package/dist/server/subagents.js

@@ -421,8 +421,16 @@ export class SubagentSupervisor {
                     }
                     if (!record)
                         break;
-                    if (record.type === "response" && record.id === "prompt" && record.success === false)
-                        throw new Error(`Pi rejected the sub-agent task: ${record.error ?? "no reason given"}`);
+                    // THE RECEIPT FOR OUR OWN PROMPT IS A KNOWN RECORD, NOT AN UNKNOWN ONE. Pi answers every
+                    // command with `type:"response"`, so the successful receipt for the prompt we just wrote is
+                    // part of the protocol - and treating it as unrecognised made every ordinary sub-agent run
+                    // log a false alarm ("unhandled child record response - consumed without action"). A FAILED
+                    // receipt is the run's failure and is thrown; a successful one is simply consumed.
+                    if (record.type === "response" && record.id === "prompt") {
+                        if (record.success === false)
+                            throw new Error(`Pi rejected the sub-agent task: ${record.error ?? "no reason given"}`);
+                        continue;
+                    }
                     if (record.type === "message_update") {
                         const event = record.assistantMessageEvent;
                         // `text_delta` is the only inner event that is output. `start` and `done` are the boundaries

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.135",
+  "version": "0.1.137",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -76,6 +76,7 @@
     "scripts/workspace-cwd.test.mjs",
     "scripts/subagents.test.mjs",
     "scripts/subagent-noise.test.mjs",
+    "scripts/subagent-response-receipt.test.mjs",
     "scripts/subagent-runs.test.mjs",
     "scripts/conversation-reconcile.test.mjs",
     "scripts/subagent-dispatch.test.mjs",
@@ -110,6 +111,8 @@
     "scripts/todo-tool.test.mjs",
     "scripts/tool-calls.test.mjs",
     "scripts/files-api.test.mjs",
+    "scripts/http-body-utf8-chunking.test.mjs",
+    "scripts/files-eol-roundtrip.test.mjs",
     "scripts/files-missing-path.test.mjs",
     "scripts/file-changes.test.mjs",
     "scripts/file-index.test.mjs",
@@ -138,6 +141,7 @@
     "scripts/provider-pi-reads.test.mjs",
     "scripts/session-extension-credentials.test.mjs",
     "scripts/active-memory.test.mjs",
+    "scripts/active-memory-index-content.test.mjs",
     "scripts/knowledge-base.test.mjs",
     "scripts/knowledge-import-path.test.mjs",
     "scripts/knowledge-import-identity.test.mjs",
@@ -164,6 +168,7 @@
     "scripts/document-write-overwrite.test.mjs",
     "scripts/feishu.test.mjs",
     "scripts/scheduled-tasks.test.mjs",
+    "scripts/scheduled-task-model-clear.test.mjs",
     "scripts/scheduled-task-scope.test.mjs",
     "scripts/scheduled-task-tool.test.mjs",
     "scripts/run-state-sync.test.mjs",
@@ -182,6 +187,9 @@
     "scripts/conversation-reconcile-browser.test.mjs",
     "scripts/visual-defects-browser.test.mjs",
     "scripts/session-state-animation-browser.test.mjs",
+    "scripts/session-state-delivery-browser.test.mjs",
+    "scripts/question-awaiting-signal-browser.test.mjs",
+    "scripts/withdraw-then-send-browser.test.mjs",
     "scripts/agent-vis-card-browser.test.mjs",
     "scripts/queue-dock.test.mjs",
     "scripts/scheduled-tasks-browser.test.mjs",