@evandu/super-pi 0.1.132 → 0.1.135

package/dist/server/http-server.js

@@ -6,6 +6,7 @@ import { homedir, networkInterfaces } from "node:os";
 import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { describe as describeFilesError, fileMeta, listDirectory, MAX_FILE_BYTES, readWorkspaceFile, resolveInsideRoot, toRelative, writeWorkspaceFile, } from "./files.js";
 import { findUploadFile, MAX_UPLOAD_BODY_BYTES, saveUpload } from "./upload.js";
+import { describeThrown } from "./failure-text.js";
 import { checkDiskVersion } from "./version.js";
 import { gitBlame, gitDiff, gitLog, gitMutate, gitStatus } from "./git.js";
 import { computeFileDiff } from "./file-diff.js";
@@ -282,7 +283,7 @@ export function createHttpServer(options) {
                 return;
             }
             catch (error) {
-                json(400, { error: error instanceof Error ? error.message : "tool export failed" });
+                json(400, { error: describeThrown(error) || "导出工具失败，没有拿到失败原因。" });
                 return;
             }
         }
@@ -360,7 +361,7 @@ export function createHttpServer(options) {
                 return;
             }
             catch (error) {
-                json(400, { error: error instanceof Error ? error.message : "tool request failed" });
+                json(400, { error: describeThrown(error) || "工具请求失败，没有拿到失败原因。" });
                 return;
             }
         }
@@ -422,7 +423,7 @@ export function createHttpServer(options) {
                     toolApi(202, run);
                 }
                 catch (error) {
-                    toolApi(400, { error: error instanceof Error ? error.message : "tool run failed" });
+                    toolApi(400, { error: describeThrown(error) || "工具运行失败，没有拿到失败原因。" });
                 }
                 return;
             }
@@ -513,7 +514,7 @@ export function createHttpServer(options) {
                         toolApi(202, context.toolLlm.start({ toolId: id, prompt: body.prompt ?? "", system: body.system, timeoutMs: body.timeoutMs }));
                     }
                     catch (error) {
-                        toolApi(400, { error: error instanceof Error ? error.message : "model call failed" });
+                        toolApi(400, { error: describeThrown(error) || "模型调用失败，没有拿到失败原因。" });
                     }
                     return;
                 }
@@ -913,6 +914,26 @@ export function createHttpServer(options) {
             }
             return;
         }
+        /**
+         * CHECKS THE CONNECTION, and says why it does not work when it does not.
+         *
+         * The status already verifies the credential against Feishu, so this is the same answer shaped
+         * for a button - the difference is that a failure comes back as a MESSAGE AND A HINT rather
+         * than as a state the panel has to interpret.
+         */
+        if (url.pathname === "/api/feishu/verify" && request.method === "POST") {
+            if (!context.feishu) {
+                response.writeHead(503).end();
+                return;
+            }
+            if (!isLocalOrPrivateAddress(remote)) {
+                json(403, { error: "测试飞书连接只允许来自本机或局域网的请求。" });
+                return;
+            }
+            const result = await context.feishu.verify();
+            json(result.ok ? 200 : 400, result);
+            return;
+        }
         if (url.pathname === "/api/shutdown") {
             if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
                 response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Shutdown requires a loopback or private network POST");
@@ -1019,6 +1040,16 @@ export function createHttpServer(options) {
                     return;
                 }
                 if (request.method === "POST") {
+                    // A GIT WRITE IS A WRITE, AND IT GETS THE SAME GATE AS EVERY OTHER WRITE. `gitMutate` can
+                    // stage, DISCARD (`git restore -- <path>`, which throws away uncommitted work), commit,
+                    // pull and PUSH - so an endpoint that skips the address predicate hands a public caller the
+                    // keys to somebody's repository. The server listens on 0.0.0.0 by default and the global
+                    // access token is OPTIONAL (`isAuthorized` passes everyone when there is none), so this
+                    // predicate IS the boundary for every other write endpoint in this file (ledger TEST-042).
+                    if (!isLocalOrPrivateAddress(remote)) {
+                        json(403, { error: "Git 写操作只允许来自本机或局域网的请求。" });
+                        return;
+                    }
                     let raw = "";
                     for await (const chunk of request)
                         raw += chunk;
@@ -1397,7 +1428,7 @@ export function createHttpServer(options) {
                 response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(result));
             }
             catch (error) {
-                response.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: error instanceof Error ? error.message : "question failed" }));
+                response.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: describeThrown(error) || "问答失败，没有拿到失败原因。" }));
             }
             return;
         }

package/dist/server/index.js

@@ -137,7 +137,10 @@ const paths = {
 const runtime = process.env.SUPER_PI_RUNTIME === "welcome"
     ? new WelcomeRuntime()
     : new PiRpcRuntime(join(dataDir, "pi-sessions"), undefined, { dir: initialAgentDirs, promptDir: agentPromptDir }, { endpoint: taskEndpoint, execEndpoint, todoEndpoint, workflowEndpoint, questionEndpoint, toolsEndpoint, documentsEndpoint, scheduledTaskEndpoint, uploadsDir });
-const broadcaster = new WsBroadcaster(() => store.snapshot());
+// THE CLIENT GETS THE VISIBLE STATE, NOT THE WHOLE STORE. `clientState()` is `snapshot()` minus the
+// workspaces that were taken out of the sidebar - they are still in the store (that is what lets the
+// same folder be added back with its history), but they are not part of the app any more.
+const broadcaster = new WsBroadcaster(() => store.clientState());
 const memory = new ActiveMemory(join(dataDir, "memories"), store, runtime);
 process.env.SUPER_PI_MEMORY_ENDPOINT = `http://${internalHost}:${port}/api/memory/tool`;
 if (runtime instanceof PiRpcRuntime)
@@ -243,7 +246,7 @@ const nameIndexes = new Map();
 runService.setNameIndexes(nameIndexes);
 const conversationService = new ConversationService(store, runtime, subagents, broadcaster, catalogService, runService, extensionUiService, initialAgentDirs);
 conversationService.setMemory(memory);
-const workspaceService = new WorkspaceService(store, runtime, broadcaster, catalogService, runService, extensionUiService, uploadsDir, initialAgentDirs);
+const workspaceService = new WorkspaceService(store, runtime, broadcaster, catalogService, runService, extensionUiService, initialAgentDirs);
 /**
  * The terminal, constructed before `serverContext` because that object carries the two predicates
  * `/api/terminal` answers with.

package/dist/server/knowledge-embedding-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/knowledge-embedding-worker.js

@@ -0,0 +1,27 @@
+import { parentPort } from "node:worker_threads";
+let extractor;
+let loading;
+async function load(request) {
+    if (extractor)
+        return extractor;
+    loading ??= (async () => {
+        const specifier = "@huggingface/transformers";
+        const transformers = await import(specifier);
+        transformers.env.localModelPath = request.modelRoot;
+        transformers.env.allowRemoteModels = false;
+        extractor = await transformers.pipeline("feature-extraction", request.model, { dtype: "q8" });
+        return extractor;
+    })();
+    return loading;
+}
+parentPort?.on("message", async (request) => {
+    try {
+        const run = await load(request);
+        const output = await run(request.texts, { pooling: "cls", normalize: true });
+        const buffer = output.data.buffer;
+        parentPort?.postMessage({ id: request.id, data: output.data, dims: output.dims }, [buffer]);
+    }
+    catch (error) {
+        parentPort?.postMessage({ id: request.id, error: error instanceof Error ? error.message : String(error) });
+    }
+});

package/dist/server/knowledge-vectors.d.ts

@@ -59,8 +59,10 @@ export type VectorDocument = {
  */
 export declare class VectorIndex {
     private readonly directory;
-    private extractor?;
-    private loading?;
+    private worker?;
+    private workerSequence;
+    private workerReady;
+    private workerPending;
     private failure?;
     private cache;
     private pending;
@@ -91,7 +93,7 @@ export declare class VectorIndex {
      * weights turns a failure mode into a file, and makes the feature work on a machine that has never
      * been online since it was installed.
      */
-    private load;
+    private ensureWorker;
     private embed;
     /** Vectors already stored for one workspace, keyed by document then chunk index. */
     private read;

package/dist/server/knowledge-vectors.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { Worker } from "node:worker_threads";
 /**
  * The model, and the only one this feature can use.
  *
@@ -78,8 +79,10 @@ export function cosine(a, b) {
  */
 export class VectorIndex {
     directory;
-    extractor;
-    loading;
+    worker;
+    workerSequence = 0;
+    workerReady = false;
+    workerPending = new Map();
     failure;
     cache = new Map();
     pending = new Set();
@@ -100,7 +103,7 @@ export class VectorIndex {
     enabled() { return process.env.SUPER_PI_KNOWLEDGE_EMBEDDINGS !== "0"; }
     status(indexed) {
         return {
-            enabled: this.enabled(), ready: Boolean(this.extractor), indexed, error: this.failure,
+            enabled: this.enabled(), ready: this.workerReady, indexed, error: this.failure,
             // Whether the shipped weights are on disk, reported before the model is ever loaded: "the
             // package was built without its assets" and "the model failed to load" are different problems.
             bundled: existsSync(this.bundledModel()),
@@ -119,57 +122,56 @@ export class VectorIndex {
      * weights turns a failure mode into a file, and makes the feature work on a machine that has never
      * been online since it was installed.
      */
-    load() {
-        if (this.extractor)
-            return Promise.resolve(this.extractor);
+    ensureWorker() {
+        if (this.worker)
+            return this.worker;
         if (this.failure)
-            return Promise.resolve(undefined);
-        this.loading ??= (async () => {
-            try {
-                if (!existsSync(this.bundledModel()))
-                    throw new Error(`随包分发的模型缺失：${this.bundledModel()}`);
-                // THE SPECIFIER GOES THROUGH A VARIABLE, and that is deliberate. Written as a literal,
-                // `tsc` resolves it while compiling - so a machine whose optional install skipped this package
-                // could not build the server at all, which makes an "optional" dependency mandatory in the
-                // only sense that matters to a person who installed it. Node resolves the variable at RUN time
-                // instead, where its absence is already handled: the throw below is the same branch that
-                // handles a missing model.
-                const specifier = "@huggingface/transformers";
-                const { pipeline, env } = await import(specifier);
-                // The library resolves `<localModelPath>/<model id>/onnx/...`, which is why the vendored tree
-                // keeps the `Xenova/bge-small-zh-v1.5` directory rather than being flattened.
-                env.localModelPath = this.bundledModel();
-                env.allowRemoteModels = false;
-                this.extractor = await pipeline("feature-extraction", KNOWLEDGE_MODEL, { dtype: "q8" });
-                return this.extractor;
-            }
-            catch (error) {
-                this.failure = error instanceof Error ? error.message : String(error);
-                console.warn(`Super Pi: 语义检索不可用，将只用关键词检索：${this.failure}`);
-                return undefined;
-            }
-            finally {
-                this.loading = undefined;
+            return undefined;
+        if (!existsSync(this.bundledModel())) {
+            this.failure = `随包分发的模型缺失：${this.bundledModel()}`;
+            return undefined;
+        }
+        const worker = new Worker(new URL("./knowledge-embedding-worker.js", import.meta.url));
+        worker.unref();
+        worker.on("message", (message) => {
+            const pending = this.workerPending.get(message.id);
+            if (!pending)
+                return;
+            this.workerPending.delete(message.id);
+            if (message.error || !message.data || !message.dims) {
+                this.failure = message.error ?? "向量 worker 返回了无效结果";
+                pending.resolve(null);
+                return;
             }
-        })();
-        return this.loading;
+            this.workerReady = true;
+            const dimension = message.dims.at(-1) ?? 0;
+            pending.resolve(Array.from({ length: message.dims[0] ?? 0 }, (_, row) => Array.from(message.data.slice(row * dimension, (row + 1) * dimension))));
+        });
+        const fail = (error) => {
+            this.failure = error.message;
+            for (const pending of this.workerPending.values())
+                pending.resolve(null);
+            this.workerPending.clear();
+            this.worker = undefined;
+            this.workerReady = false;
+        };
+        worker.on("error", fail);
+        worker.on("exit", (code) => { if (code !== 0)
+            fail(new Error(`向量 worker 异常退出（${code}）`)); });
+        this.worker = worker;
+        return worker;
     }
     async embed(texts) {
         if (!texts.length || !this.enabled())
             return null;
-        const extractor = await this.load();
-        if (!extractor)
+        const worker = this.ensureWorker();
+        if (!worker)
             return null;
-        try {
-            const output = await extractor(texts, { pooling: "cls", normalize: true });
-            const dimension = output.dims[output.dims.length - 1];
-            return Array.from({ length: output.dims[0] }, (_, row) => Array.from(output.data.slice(row * dimension, (row + 1) * dimension)));
-        }
-        catch (error) {
-            this.failure = error instanceof Error ? error.message : String(error);
-            console.warn(`Super Pi: 生成向量失败，将只用关键词检索：${this.failure}`);
-            return null;
-        }
+        const id = ++this.workerSequence;
+        return new Promise((resolvePromise) => {
+            this.workerPending.set(id, { resolve: resolvePromise });
+            worker.postMessage({ id, texts, modelRoot: this.bundledModel(), model: KNOWLEDGE_MODEL });
+        });
     }
     /** Vectors already stored for one workspace, keyed by document then chunk index. */
     async read(workspaceId, documentId) {

package/dist/server/knowledge.d.ts

@@ -125,6 +125,7 @@ export declare class KnowledgeBase {
     private indexes;
     private serial;
     constructor(directory: string, store: Store, runtime?: KnowledgeRuntime | undefined, vectors?: VectorIndex | undefined);
+    private hasWorkspace;
     /** `SUPER_PI_KNOWLEDGE_ENABLED=0` turns the whole feature off, the same way memory turns off. */
     enabled(): boolean;
     /** The opaque workspace identity on disk, encoded. Paths never come from the model or the request. */

package/dist/server/knowledge.js

@@ -253,13 +253,17 @@ export class KnowledgeBase {
         this.runtime = runtime;
         this.vectors = vectors;
     }
+    hasWorkspace(workspaceId) {
+        const store = this.store;
+        return store.hasWorkspace ? store.hasWorkspace(workspaceId) : store.snapshot().workspaces.some(workspace => workspace.id === workspaceId);
+    }
     /** `SUPER_PI_KNOWLEDGE_ENABLED=0` turns the whole feature off, the same way memory turns off. */
     enabled() { return process.env.SUPER_PI_KNOWLEDGE_ENABLED !== "0"; }
     /** The opaque workspace identity on disk, encoded. Paths never come from the model or the request. */
     folder(workspaceId) { return join(this.directory, Buffer.from(workspaceId).toString("hex")); }
     file(workspaceId, documentId) { return join(this.folder(workspaceId), `${documentId}.json`); }
     requireWorkspace(workspaceId) {
-        if (!this.store.snapshot().workspaces.some(workspace => workspace.id === workspaceId))
+        if (!this.hasWorkspace(workspaceId))
             throw new Error("工作区不存在");
     }
     async locked(work) {
@@ -710,7 +714,7 @@ export class KnowledgeBase {
         const identity = this.capabilities.get(token);
         // The workspace is re-checked against the store, so a token minted before a workspace was deleted
         // cannot keep serving its documents afterwards.
-        if (!identity || !this.store.snapshot().workspaces.some(workspace => workspace.id === identity.workspaceId))
+        if (!identity || !this.hasWorkspace(identity.workspaceId))
             throw new Error("知识库授权已失效");
         return identity;
     }

package/dist/server/persistence/sqlite-state-repository.d.ts

@@ -1,6 +1,5 @@
 import type { AppState } from "../types.js";
 import type { AppStateRepository, StateTransaction } from "./app-state-repository.js";
-/** SQLite snapshot adapter with row-level writes for streamed messages and runs. */
 export declare class SqliteStateRepository implements AppStateRepository {
     private readonly db;
     constructor(path: string);

package/dist/server/persistence/sqlite-state-repository.js

@@ -1,5 +1,24 @@
 import { DatabaseSync } from "node:sqlite";
 /** SQLite snapshot adapter with row-level writes for streamed messages and runs. */
+/**
+ * THE ROW THAT SAYS "THIS CONVERSATION'S ARRAY IS EMPTY".
+ *
+ * A missing row in `message_order` used to mean two different things: "this conversation was never
+ * written incrementally" AND "this conversation's array was emptied". The loader could only read the
+ * first one, so a conversation whose LAST message was withdrawn fell back to the base snapshot - and
+ * the withdrawn message came back, carrying `delivery: "waiting"`, to be handed to the model by the
+ * next turn. A withdrawal is the last act of "take back what I have not sent yet", and it did not
+ * survive a restart (ledger TEST-041).
+ *
+ * A sentinel row says the difference. It is marked by a NEGATIVE POSITION - a real message's
+ * position is never negative - so it is never mistaken for one, and the loader reads it as "empty"
+ * rather than as "not written". (The marker is the position and NOT the id on purpose: a NUL in the
+ * id would be truncated by SQLite's TEXT handling, and the row would stop being recognisable.)
+ */
+const EMPTY_ARRAY_POSITION = -1;
+/** The id that goes with the sentinel row. It never becomes a message: the loader drops every row
+ *  whose position is negative, and this row's position IS negative. */
+const EMPTY_ARRAY_SENTINEL_ID = "empty-array";
 export class SqliteStateRepository {
     db;
     constructor(path) {
@@ -58,7 +77,12 @@ export class SqliteStateRepository {
             // was last rewritten - the placeholder an assistant message was born with, not what it streamed.
             const ordered = this.db.prepare("SELECT id,position,json FROM message_order WHERE conversation=? ORDER BY position").all(conversation.id);
             if (ordered.length) {
-                conversation.messages = ordered.map((row) => overrides.get(String(row.id)) ?? JSON.parse(String(row.json)));
+                // Rows EXIST, so this conversation was written incrementally and these rows are authoritative -
+                // including the sentinel, which says the array is empty. The sentinel is not a message and
+                // never becomes one.
+                conversation.messages = ordered
+                    .filter((row) => Number(row.position) >= 0)
+                    .map((row) => overrides.get(String(row.id)) ?? JSON.parse(String(row.json)));
             }
             else {
                 if (!Array.isArray(conversation.messages))
@@ -120,6 +144,24 @@ export class SqliteStateRepository {
             }
             else if (transaction.kind === "collections.remove") {
                 this.db.prepare("DELETE FROM collections WHERE name=?").run(transaction.name);
+                // AND THE BASE SNAPSHOT MUST STOP CARRYING IT TOO. Deleting only the overlay row was not
+                // enough: this loader treats an overlay as a PURE INCREMENT - "no row for this name" means
+                // "read it from the base snapshot" - so the base's stale array came back on the next load,
+                // and a scheduled task the user had deleted was resurrected and ran again on its old
+                // schedule (ledger TEST-038). "This collection is empty" is stored as the ABSENCE of the key
+                // (app-state-repository.ts), so the base has to lose the key as well - the row's deletion
+                // alone cannot express it, because the base is where the value would come from.
+                //
+                // The json backend has no incremental path and falls back to a whole-state save, which is
+                // why it was always right; that asymmetry is what makes this a defect and not a choice.
+                const base = this.db.prepare("SELECT json FROM state WHERE id=1").get();
+                if (base) {
+                    const parsed = JSON.parse(String(base.json));
+                    if (transaction.name in parsed) {
+                        delete parsed[transaction.name];
+                        this.db.prepare("UPDATE state SET json=? WHERE id=1").run(JSON.stringify(parsed));
+                    }
+                }
             }
             else if (transaction.kind === "conversation.messages") {
                 // A DIFF, NOT A REWRITE. This used to DELETE the conversation's rows and re-INSERT every
@@ -145,6 +187,12 @@ export class SqliteStateRepository {
                         upsertMessage.run(conversationId, message.id, json);
                         insertOrdered.run(conversationId, message.id, position, json);
                     });
+                    // An EMPTY ARRAY MUST BE WRITTEN DOWN, or "no rows" will read as "never written" and the
+                    // loader will fall back to the base snapshot - which still holds the message the person
+                    // just withdrew (ledger TEST-041).
+                    if (transaction.messages.length === 0) {
+                        insertOrdered.run(conversationId, EMPTY_ARRAY_SENTINEL_ID, EMPTY_ARRAY_POSITION, "[]");
+                    }
                 }
                 else {
                     const nextIds = new Set(transaction.messages.map((message) => message.id));
@@ -167,6 +215,12 @@ export class SqliteStateRepository {
                         if (positions.get(message.id) !== position)
                             upsertOrder.run(conversationId, message.id, position, json);
                     });
+                    // The LAST MESSAGE GONE leaves the order table with no rows, and no rows read as "never
+                    // written" - so the loader would fall back to the base snapshot and hand the withdrawn
+                    // message back to the model. The sentinel says the array is empty (ledger TEST-041).
+                    if (transaction.messages.length === 0) {
+                        upsertOrder.run(conversationId, EMPTY_ARRAY_SENTINEL_ID, EMPTY_ARRAY_POSITION, "[]");
+                    }
                 }
                 // The stamp is WRITTEN, not cleared. Opening a turn moves `updatedAt`, and this is the only write
                 // that can record it; clearing the overlay instead would leave the reopened conversation reporting

package/dist/server/pi-session-events.js

@@ -16,7 +16,7 @@
  * be announced as unhandled is still announced as unhandled - this bridge changes WHERE the events come
  * from, not what they mean.
  */
-import { describeToolCall, describeToolCallArgs, extractPartialResultText } from "./tool-calls.js";
+import { describeToolCall, describeToolCallArgs, extractPartialResultText, readQuestionCall } from "./tool-calls.js";
 import { toolTargetPath } from "./file-changes.js";
 /** Keeps only real strings, so a malformed queue snapshot cannot put objects into a broadcast. */
 const textList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : undefined;
@@ -254,7 +254,15 @@ export function handleSessionEvent(event, queue, handlers, report, failure) {
                 return true;
             const name = record.toolName ?? "unknown";
             try {
-                handlers.onToolCall?.({ id, name, detail: describeToolCall(name, record.args), args: describeToolCallArgs(record.args) });
+                // A `question` CALL IS READ HERE, AT `tool_execution_start` - the same place the one-shot path
+                // reads it, and for the same reason: the card on screen must be the tool call the model is
+                // actually blocked in, with the same identity and the same lifecycle. This path left the
+                // question out, so the host never saw a pending question and the model was told the session
+                // had no question waiting for an answer - the `question` tool was simply dead on the SDK
+                // session path, which is the PRODUCTION default (ledger TEST-037). Two paths must give the
+                // same answer to "what is a question call".
+                const question = readQuestionCall(name, record.args);
+                handlers.onToolCall?.({ id, name, detail: describeToolCall(name, record.args), args: describeToolCallArgs(record.args), ...(question ? { question } : {}) });
             }
             catch (error) {
                 console.warn(`PiRpcRuntime: the tool call handler threw: ${error instanceof Error ? error.message : "unknown error"}`);

package/dist/server/pi-session-pool.d.ts

@@ -87,6 +87,22 @@ export declare class PiSessionPool {
      * where that gets fixed.
      */
     private readonly modelEpoch;
+    /**
+     * Mints the OTHER per-session credentials the extensions need, at the moment the session is born.
+     *
+     * WHY A SECOND CALLBACK AND NOT PART OF THE CAPABILITY. The memory and knowledge extensions each
+     * need their own credential - the memory one even carries per-caller flags (read-only for a
+     * sub-agent) that a single session capability cannot express. The one-shot path has always minted
+     * them per turn; the SESSION path minted none, so those two extensions returned before registering
+     * a single tool or injecting a single line of prompt, and both features were absent in production -
+     * the SDK session path is the default backend, and only the test scripts use the one-shot path
+     * (ledger TEST-039).
+     *
+     * They are minted HERE, where the session is born, for the same reason the capability is: the
+     * extension reads its environment ONCE, when it is loaded, so a token minted per turn would be
+     * replaced before the second turn and the extension would still be holding the first turn's value.
+     */
+    private readonly mintExtensionTokens;
     private readonly sessions;
     constructor(
     /** Where Pi keeps its session files. */
@@ -122,7 +138,23 @@ export declare class PiSessionPool {
      * settings window makes every live session unable to reach the new model, and the next turn is
      * where that gets fixed.
      */
-    modelEpoch?: () => number);
+    modelEpoch?: () => number, 
+    /**
+     * Mints the OTHER per-session credentials the extensions need, at the moment the session is born.
+     *
+     * WHY A SECOND CALLBACK AND NOT PART OF THE CAPABILITY. The memory and knowledge extensions each
+     * need their own credential - the memory one even carries per-caller flags (read-only for a
+     * sub-agent) that a single session capability cannot express. The one-shot path has always minted
+     * them per turn; the SESSION path minted none, so those two extensions returned before registering
+     * a single tool or injecting a single line of prompt, and both features were absent in production -
+     * the SDK session path is the default backend, and only the test scripts use the one-shot path
+     * (ledger TEST-039).
+     *
+     * They are minted HERE, where the session is born, for the same reason the capability is: the
+     * extension reads its environment ONCE, when it is loaded, so a token minted per turn would be
+     * replaced before the second turn and the extension would still be holding the first turn's value.
+     */
+    mintExtensionTokens?: (conversationId: string) => Promise<Record<string, string>> | Record<string, string>);
     /**
      * The session for a conversation, built if there is none and REPLACED if the live one is stale.
      *

package/dist/server/pi-session-pool.js

@@ -49,6 +49,7 @@ export class PiSessionPool {
     factory;
     mintCapability;
     modelEpoch;
+    mintExtensionTokens;
     sessions = new Map();
     constructor(
     /** Where Pi keeps its session files. */
@@ -84,7 +85,23 @@ export class PiSessionPool {
      * settings window makes every live session unable to reach the new model, and the next turn is
      * where that gets fixed.
      */
-    modelEpoch = () => 0) {
+    modelEpoch = () => 0, 
+    /**
+     * Mints the OTHER per-session credentials the extensions need, at the moment the session is born.
+     *
+     * WHY A SECOND CALLBACK AND NOT PART OF THE CAPABILITY. The memory and knowledge extensions each
+     * need their own credential - the memory one even carries per-caller flags (read-only for a
+     * sub-agent) that a single session capability cannot express. The one-shot path has always minted
+     * them per turn; the SESSION path minted none, so those two extensions returned before registering
+     * a single tool or injecting a single line of prompt, and both features were absent in production -
+     * the SDK session path is the default backend, and only the test scripts use the one-shot path
+     * (ledger TEST-039).
+     *
+     * They are minted HERE, where the session is born, for the same reason the capability is: the
+     * extension reads its environment ONCE, when it is loaded, so a token minted per turn would be
+     * replaced before the second turn and the extension would still be holding the first turn's value.
+     */
+    mintExtensionTokens = () => ({})) {
         this.sessionDir = sessionDir;
         this.repositoryRoot = repositoryRoot;
         this.agentDir = agentDir;
@@ -92,6 +109,7 @@ export class PiSessionPool {
         this.factory = factory;
         this.mintCapability = mintCapability;
         this.modelEpoch = modelEpoch;
+        this.mintExtensionTokens = mintExtensionTokens;
     }
     /**
      * The session for a conversation, built if there is none and REPLACED if the live one is stale.
@@ -138,7 +156,7 @@ export class PiSessionPool {
         // server separately requires that a turn is RUNNING for the token to be usable, which is what keeps a
         // longer-lived token from being a weaker credential than a per-turn one.
         const capability = this.mintCapability(request.conversationId);
-        const extensionEnv = { ...request.extensionEnv, [CAPABILITY_ENV]: capability, [TOOLS_CAPABILITY_ENV]: capability };
+        const extensionEnv = { ...request.extensionEnv, [CAPABILITY_ENV]: capability, [TOOLS_CAPABILITY_ENV]: capability, ...await this.mintExtensionTokens(request.conversationId) };
         const building = this.build({ ...request, extensionEnv }, fingerprint);
         if (process.env.SUPER_PI_TRACE_LATENCY === "1")
             console.warn(`[super-pi latency] conversation=${request.conversationId} phase=session.build.begin`);

package/dist/server/providers.d.ts

@@ -284,3 +284,16 @@ export declare function fetchRemoteModels(input: {
     apiKey?: string;
     api?: string;
 }): Promise<DiscoveredModel[]>;
+/**
+ * THE ANSWER, READ.
+ *
+ * Split out of `fetchRemoteModels` so that the part worth asserting - what a provider's answer MEANS -
+ * can be tested without a network in between. A remote provider answers in three shapes (a bare array,
+ * `{data: [...]}` for OpenAI, `{models: [...]}` for Ollama), and each entry names itself with `id`,
+ * `name` or `model`; what the panel shows next to it - whether the model reasons, whether it takes
+ * images - is inferred from the name, because that is all most providers tell us.
+ *
+ * `fetchRemoteModels` is the transport; this is the reading. Keeping them apart means the reading can
+ * be pinned exactly, and a slow machine can never turn a parsing question into a timeout.
+ */
+export declare function parseRemoteModels(payload: unknown): DiscoveredModel[];

package/dist/server/providers.js

@@ -741,6 +741,7 @@ export async function fetchRemoteModels(input) {
         candidates.push(`${cleanBase}/v1/models`, `${cleanBase}/models`);
     }
     let lastError = "";
+    let lastCause;
     let payload = null;
     for (const candidate of candidates) {
         try {
@@ -758,11 +759,35 @@ export async function fetchRemoteModels(input) {
         }
         catch (error) {
             lastError = error instanceof Error ? error.message : String(error);
+            lastCause = error;
         }
     }
     if (!payload) {
-        throw new Error(`无法从远程服务获取模型列表 (${lastError || "请求超时或无法连接"})`);
-    }
+        // THE CAUSE, NOT JUST "fetch failed". `fetch` reports every transport-level problem - a refused
+        // connection, a reset, an aborted timeout - as the same one-word "fetch failed", so a user staring
+        // at 「无法从远程服务获取模型列表 (fetch failed)」 learns nothing and neither does the log. The
+        // cause is where the truth is: "The operation was aborted due to timeout" and "connect
+        // ECONNREFUSED" are two different problems with two different fixes.
+        const cause = lastCause instanceof Error
+            ? (lastCause.cause instanceof Error ? lastCause.cause.message : lastCause.cause instanceof Object && lastCause.cause !== null ? String(lastCause.cause.code ?? "") : undefined)
+            : undefined;
+        throw new Error(`无法从远程服务获取模型列表 (${lastError || "请求超时或无法连接"}${cause ? `：${cause}` : ""})`);
+    }
+    return parseRemoteModels(payload);
+}
+/**
+ * THE ANSWER, READ.
+ *
+ * Split out of `fetchRemoteModels` so that the part worth asserting - what a provider's answer MEANS -
+ * can be tested without a network in between. A remote provider answers in three shapes (a bare array,
+ * `{data: [...]}` for OpenAI, `{models: [...]}` for Ollama), and each entry names itself with `id`,
+ * `name` or `model`; what the panel shows next to it - whether the model reasons, whether it takes
+ * images - is inferred from the name, because that is all most providers tell us.
+ *
+ * `fetchRemoteModels` is the transport; this is the reading. Keeping them apart means the reading can
+ * be pinned exactly, and a slow machine can never turn a parsing question into a timeout.
+ */
+export function parseRemoteModels(payload) {
     const rawList = Array.isArray(payload)
         ? payload
         : Array.isArray(payload.data)