@evandu/super-pi 0.1.101 → 0.1.102

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-gjLqMWYT.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-8olCbCbk.css">
+    <script type="module" crossorigin src="/assets/index-pD4FaDWr.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DDkbPYLz.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/application/catalog-service.d.ts

@@ -58,6 +58,27 @@ export declare class CatalogService {
      * Broadcasts subagents to connected clients.
      */
     broadcastSubagents(): Promise<void>;
+    /**
+     * Sets the app-wide default model, or clears it back to "Pi's own default".
+     *
+     * THE MODEL IS CHECKED AGAINST PI'S OWN CATALOG, for the same reason the workspace default is:
+     * a default Pi does not offer would be stamped onto every new conversation, and the first turn
+     * would fail on a model the user never chose. The check happens at SAVE time rather than at
+     * birth time so the user hears about it while they are still looking at the list.
+     *
+     * The label is taken from the catalog row rather than from the request, so the stored value
+     * always carries the display name Pi itself reported.
+     */
+    setDefaultModel(model: {
+        provider: string;
+        modelId: string;
+    } | null): Promise<void>;
+    /**
+     * The UNFILTERED catalog, for the settings window's model panel. Deliberately not the scoped one:
+     * the panel is where the app-wide default is chosen, and a workspace's model rules must not hide
+     * models from the place that decides what the app-wide default may be.
+     */
+    getAllCatalog(): Promise<ModelCatalog>;
     /**
      * Helper formatting an error when a requested model/thinking level is not offered by Pi.
      */

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

@@ -165,6 +165,43 @@ export class CatalogService {
     async broadcastSubagents() {
         this.broadcaster.broadcast({ type: "subagent.catalog", catalog: await this.subagentCatalog() });
     }
+    /**
+     * Sets the app-wide default model, or clears it back to "Pi's own default".
+     *
+     * THE MODEL IS CHECKED AGAINST PI'S OWN CATALOG, for the same reason the workspace default is:
+     * a default Pi does not offer would be stamped onto every new conversation, and the first turn
+     * would fail on a model the user never chose. The check happens at SAVE time rather than at
+     * birth time so the user hears about it while they are still looking at the list.
+     *
+     * The label is taken from the catalog row rather than from the request, so the stored value
+     * always carries the display name Pi itself reported.
+     */
+    async setDefaultModel(model) {
+        if (!this.store)
+            throw new Error("Store unavailable");
+        let selection;
+        if (model) {
+            const catalog = await this.runtime.catalog();
+            const option = catalog.source === "pi"
+                ? catalog.models.find(item => item.provider === model.provider && item.modelId === model.modelId)
+                : undefined;
+            if (catalog.source === "pi" && !option)
+                throw this.notOffered(`模型 ${model.provider}/${model.modelId}`, catalog);
+            selection = option
+                ? { provider: option.provider, modelId: option.modelId, label: option.label }
+                : { provider: model.provider, modelId: model.modelId, label: model.modelId };
+        }
+        await this.store.setDefaultModel(selection);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * The UNFILTERED catalog, for the settings window's model panel. Deliberately not the scoped one:
+     * the panel is where the app-wide default is chosen, and a workspace's model rules must not hide
+     * models from the place that decides what the app-wide default may be.
+     */
+    async getAllCatalog() {
+        return this.runtime.catalog();
+    }
     /**
      * Helper formatting an error when a requested model/thinking level is not offered by Pi.
      */

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

@@ -42,7 +42,13 @@ export class ConversationService {
         // stamp a dead selection onto every new conversation: the scoped catalog probe would
         // fail and leave the model/thinking controls unavailable. A missing or invalid default
         // means "follow Pi's current default" for this newly-created conversation.
-        let model = workspace.defaultModel;
+        // THE PRECEDENCE AT BIRTH IS WORKSPACE > APP > Pi. The app-wide default is a FALLBACK, not an
+        // override: a workspace that has a default of its own keeps it, and only a workspace with none
+        // inherits the app-wide one. Both are copied onto the conversation and never consulted again,
+        // so changing either default never rewrites an existing conversation.
+        const appDefault = this.store.snapshot().defaultModel;
+        const inheritsAppDefault = !workspace.defaultModel && Boolean(appDefault);
+        let model = workspace.defaultModel ?? appDefault;
         let thinkingLevel = workspace.defaultThinkingLevel;
         const catalog = model || thinkingLevel ? await this.runtime.catalog() : undefined;
         if (catalog?.source === "pi" && model) {
@@ -60,6 +66,19 @@ export class ConversationService {
                 }
             }
         }
+        if (inheritsAppDefault && model) {
+            // An app-wide default belongs to no workspace, so the workspace's model rules are checked HERE,
+            // at birth, where the workspace is finally known. A default the rules forbid is not stamped
+            // on: the conversation starts on Pi's own default instead, which is the same outcome as a
+            // workspace default that pointed at a model Pi no longer offers.
+            try {
+                assertModelAllowed(this.store.snapshot().modelFilterRules, workspace, model);
+            }
+            catch {
+                model = undefined;
+                thinkingLevel = undefined;
+            }
+        }
         const resolved = workspace.defaultAgentId
             ? await this.resolveAgentConfiguration({ id: workspaceId, model, thinkingLevel }, workspace.defaultAgentId, workspaceId)
             : { model, thinkingLevel };

package/dist/server/command-handler.js

@@ -65,6 +65,10 @@ export class CommandHandler {
             await this.catalogService.setModelRules(command.rules);
             return;
         }
+        if (command.type === "settings.defaultModel") {
+            await this.catalogService.setDefaultModel(command.model);
+            return;
+        }
         if (command.type === "workspace.create") {
             return await this.workspaceService.createWorkspace(command.name, command.path);
         }
@@ -239,6 +243,14 @@ export class CommandHandler {
                 await this.catalogService.broadcastCatalog(undefined, command.conversationId);
             return;
         }
+        // The unfiltered catalog, for the settings window's model panel. Sent to the ASKING socket only:
+        // it is a panel's private list, and broadcasting it would overwrite every open conversation's
+        // filtered catalog with one that no workspace's rules apply to.
+        if (command.type === "catalog.fetchAll") {
+            if (sendToSocket)
+                sendToSocket({ type: "model.catalog.all", catalog: await this.catalogService.getAllCatalog() });
+            return;
+        }
         if (command.type === "agent.catalog.fetch") {
             await this.catalogService.broadcastAgents();
             return;

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

@@ -184,6 +184,15 @@ export interface PiSessionLike {
     readonly sessionFile?: string | undefined;
     /** The id of the session. */
     readonly sessionId?: string | undefined;
+    /**
+     * The system prompt Pi will send with every turn.
+     *
+     * READ FOR ITS SIZE, not for its content. The time to first token is a function of how many bytes
+     * the provider has to receive before it can answer, so this number is what turns "the model was
+     * slow" into a fact. Pi builds the prompt from the agent directory, the skills, the extensions and
+     * the context files - none of which Super Pi controls.
+     */
+    readonly systemPrompt?: string | undefined;
     /**
      * The model the session is running on.
      *

package/dist/server/runtime.js

@@ -755,12 +755,29 @@ export class PiRpcRuntime {
             abortTurn();
         else
             signal.addEventListener("abort", onAbort, { once: true });
+        // HOW BIG IS THE PROMPT WE ARE ABOUT TO SEND. The time to first token is a function of
+        // this, not of anything Super Pi does, and it is the number that explains a slow first turn: the
+        // model's provider has to RECEIVE the whole thing before it can answer, so a big prompt on a slow
+        // link is seconds before the first word.
+        //
+        // It is traced rather than computed, because the system prompt is what Pi builds from the agent
+        // directory, the skills, the extensions and the context files - none of which Super Pi controls,
+        // and all of which the person who installed them controls.
+        const promptSize = () => {
+            try {
+                const system = typeof session.systemPrompt === "string" ? session.systemPrompt : "";
+                return `systemPrompt=${Buffer.byteLength(system, "utf8")}B`;
+            }
+            catch {
+                return "systemPrompt=?";
+            }
+        };
         let firstTextSeen = false;
         const finished = (async () => {
             try {
                 const promptOptions = images?.length
-                    ? { images: images, preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt) }
-                    : { preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt) };
+                    ? { images: images, preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt, promptSize()) }
+                    : { preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt, promptSize()) };
                 await session.prompt(prompt, promptOptions);
                 // `prompt()` RETURNING IS NOT THE TURN ENDING. Pi's `prompt` resolves when the message has
                 // been ACCEPTED and the run has been started; the agent is still streaming, still executing

package/dist/server/store.d.ts

@@ -78,6 +78,18 @@ export declare class Store {
     /** Opens an injected repository, retaining domain reconciliation here. */
     static openRepository(repository: AppStateRepository): Promise<Store>;
     setModelFilterRules(rules: import("./types.js").ModelFilterRule[]): Promise<void>;
+    /**
+     * Sets (or clears) the app-wide default model.
+     *
+     * `undefined` DELETES the key, for the same reason the workspace defaults do it that way: "follow
+     * Pi" has to be the ABSENCE of a value, not a frozen copy of whatever Pi's default was when the
+     * setting was saved. A stored copy would keep answering with a model the user had already
+     * removed, and Pi's own default may have changed underneath us in the meantime.
+     *
+     * The pair is written field by field, never as a spread, because the type declares exactly three
+     * fields and a spread would quietly start persisting whatever is added to `ModelSelection` next.
+     */
+    setDefaultModel(model?: ModelSelection): Promise<void>;
     snapshot(): AppState;
     createWorkspace(name: string, path?: string): Promise<Workspace>;
     renameWorkspace(workspaceId: string, name: string): Promise<Workspace>;

package/dist/server/store.js

@@ -596,6 +596,31 @@ export class Store {
             throw error;
         }
     }
+    /**
+     * Sets (or clears) the app-wide default model.
+     *
+     * `undefined` DELETES the key, for the same reason the workspace defaults do it that way: "follow
+     * Pi" has to be the ABSENCE of a value, not a frozen copy of whatever Pi's default was when the
+     * setting was saved. A stored copy would keep answering with a model the user had already
+     * removed, and Pi's own default may have changed underneath us in the meantime.
+     *
+     * The pair is written field by field, never as a spread, because the type declares exactly three
+     * fields and a spread would quietly start persisting whatever is added to `ModelSelection` next.
+     */
+    async setDefaultModel(model) {
+        const previous = this.state.defaultModel;
+        if (model === undefined)
+            delete this.state.defaultModel;
+        else
+            this.state.defaultModel = { provider: model.provider, modelId: model.modelId, label: model.label };
+        try {
+            await this.persist();
+        }
+        catch (error) {
+            this.state.defaultModel = previous;
+            throw error;
+        }
+    }
     snapshot() { return structuredClone(this.state); }
     async createWorkspace(name, path) {
         const cleanName = name.trim();

package/dist/server/types.d.ts

@@ -730,8 +730,19 @@ export type BackgroundTaskSummary = {
  * import and is erased at compile time, so it does not close a runtime cycle with the rules that
  * construct them - the same relationship `SubagentRun` already has with `subagent-runs.ts`.
  */
+/**
+ * `defaultModel` is the app-wide fallback model: the `provider/modelId` pair a NEW conversation gets
+ * when its workspace has no default of its own. It sits BELOW the workspace default and ABOVE Pi's own
+ * default, so the precedence at birth is workspace > app > Pi.
+ *
+ * It is a PAIR, never a provider and a model apart, for the same reason `ModelSelection` is a pair:
+ * Pi's `set_model` needs both halves, and half a selection is a selection Pi refuses. There is no
+ * separate "default provider" anywhere in this state: a provider is not a thing this app can be
+ * configured with, it is only the first half of a model id.
+ */
 export type AppState = {
     modelFilterRules?: ModelFilterRule[];
+    defaultModel?: ModelSelection;
     workspaces: Workspace[];
     conversations: Conversation[];
     subagentRuns: SubagentRun[];
@@ -862,6 +873,27 @@ export type ClientCommandBody =
 } | {
     type: "model.rules.set";
     rules: ModelFilterRule[];
+}
+/**
+ * Sets the app-wide default model. `null` clears it back to "Pi's own default" - the same
+ * "absence, not a frozen copy" convention the workspace defaults use, so removing the default
+ * really removes it instead of pinning whatever Pi's default happened to be when it was saved.
+ */
+ | {
+    type: "settings.defaultModel";
+    model: {
+        provider: string;
+        modelId: string;
+    } | null;
+}
+/**
+ * Asks for the model catalog WITHOUT a conversation, so the settings window can list every model Pi
+ * offers. A separate command from `catalog.fetch` because that one is scoped to a conversation and
+ * filtered by that workspace's model rules: reusing it here would either hide the models the panel
+ * must offer, or - worse - leak them into the composer picker, which is filtered for a reason.
+ */
+ | {
+    type: "catalog.fetchAll";
 } | {
     type: "workspace.create";
     name: string;
@@ -1287,6 +1319,17 @@ export type ServerEvent = {
     catalog: ModelCatalog;
     conversationId?: string;
 }
+/**
+ * The UNFILTERED catalog, for the settings window's model panel. A different event type from
+ * `model.catalog` on purpose: that one is scoped to a conversation and filtered by that
+ * workspace's model rules, and the settings panel must be able to offer the models the rules
+ * hide - while the composer picker must keep hiding them. One event carrying both would force
+ * one of the two to be wrong.
+ */
+ | {
+    type: "model.catalog.all";
+    catalog: ModelCatalog;
+}
 /**
  * The answer to conversation.autoRename. Carries a title OR an error and never both, because the client
  * has exactly two things to say about it: here is the new name, or here is why there isnt one.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.101",
+  "version": "0.1.102",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -90,6 +90,7 @@
     "scripts/theme-no-hardcoded-colours.test.mjs",
     "scripts/agent-config-regression.test.mjs",
     "scripts/model-filter.test.mjs",
+    "scripts/settings-default-model.test.mjs",
     "scripts/active-memory.test.mjs",
     "scripts/knowledge-base.test.mjs",
     "scripts/tool-runner.test.mjs",
@@ -135,6 +136,7 @@
     "scripts/theme-contrast.test.mjs",
     "scripts/theme-switch-state.test.mjs",
     "scripts/settings-window-structure.test.mjs",
+    "scripts/settings-model-browser.test.mjs",
     "scripts/file-tab-selected-contrast.test.mjs",
     "scripts/help-window.test.mjs",
     "scripts/composer-regression-browser.test.mjs",

package/scripts/diagnose.mjs

@@ -216,6 +216,8 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
       }
       await sleep(250);
       const added = log.slice(logMark);
+      const promptSize = /systemPrompt=(\d+)B/.exec(added)?.[1];
+      if (promptSize) result.systemPromptBytes = Number(promptSize);
       result.turns.push({
         turn,
         toWaitingMs: waiting - sent,
@@ -350,6 +352,13 @@ export function renderReport(result) {
   lines.push(`    建立的会话数：      ${built}`);
   lines.push(`    复用的会话数：      ${reused}`);
 
+  if (result.systemPromptBytes) {
+    lines.push("");
+    lines.push(`  发给模型的系统提示：${(result.systemPromptBytes / 1024).toFixed(1)}KB`);
+    lines.push("  这是每一轮都要先传过去的东西。模型的 provider 得先收下它才能回答，");
+    lines.push("  所以在慢链路上，它直接就是首字之前的那几秒。");
+  }
+
   const real = result.realState;
   if (real && real.path) {
     lines.push("");