@evandu/super-pi 0.1.104 → 0.1.105

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

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

@@ -37,6 +37,15 @@ export declare class CatalogService {
      * Broadcasts the model catalog to connected clients.
      */
     broadcastCatalog(selection?: ModelSelection, conversationId?: string): Promise<void>;
+    /**
+     * Broadcasts the UNFILTERED catalog, for the settings window's model panel.
+     *
+     * A SEPARATE EVENT FROM `model.catalog`, and the reason is the same one that made
+     * `model.catalog.all` a separate event in the first place: a `model.catalog` without a
+     * conversation is the unfiltered list, and a client that received it as its conversation's list
+     * would be offered the models that workspace's rules forbid. The panel gets its own event.
+     */
+    broadcastAllCatalog(): Promise<void>;
     setModelRules(rules: import("../types.js").ModelFilterRule[]): Promise<void>;
     /**
      * Reads one catalog filtered by mode at source.

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

@@ -90,6 +90,17 @@ export class CatalogService {
         const catalog = await this.getCatalog(selection, conversationId);
         this.broadcaster.broadcast({ type: "model.catalog", catalog, conversationId });
     }
+    /**
+     * Broadcasts the UNFILTERED catalog, for the settings window's model panel.
+     *
+     * A SEPARATE EVENT FROM `model.catalog`, and the reason is the same one that made
+     * `model.catalog.all` a separate event in the first place: a `model.catalog` without a
+     * conversation is the unfiltered list, and a client that received it as its conversation's list
+     * would be offered the models that workspace's rules forbid. The panel gets its own event.
+     */
+    async broadcastAllCatalog() {
+        this.broadcaster.broadcast({ type: "model.catalog.all", catalog: await this.getAllCatalog() });
+    }
     async setModelRules(rules) {
         if (!this.store)
             throw new Error("Store unavailable");

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

@@ -0,0 +1,63 @@
+import { ProviderRegistry } from "../providers.js";
+import type { AgentRuntime } from "../runtime.js";
+import type { Store } from "../store.js";
+import type { PublicProvider } from "../types.js";
+import type { EventBroadcaster } from "../server-context.js";
+import type { CatalogService } from "./catalog-service.js";
+/**
+ * THE PROVIDERS A PERSON ADDED, as a service.
+ *
+ * The service owns the sequence, and the sequence is the whole point: a provider is not "saved"
+ * when it is in Super Pi's registry, it is saved when Pi can use it. So every change goes through
+ * the same four steps, in this order:
+ *
+ *   1. WRITE PI'S FILES. The definitions go into Pi's `models.json` and the key into Pi's
+ *      `auth.json`, merged into whatever is already there.
+ *   2. WRITE SUPER PI'S REGISTRY. It is the truth source, and it is written AFTER Pi's files so
+ *      that a failure to write them leaves Super Pi claiming nothing it has not done.
+ *   3. INVALIDATE THE CATALOG. Pi's model list is cached - the SDK's is remembered for the life of
+ *      the process and the runtime's has a ten-minute TTL - so a provider added now would not
+ *      appear in the picker until the cache expired. Ten minutes of a picker that cannot see the
+ *      model the person just added is exactly the "decorative control" this project refuses to ship.
+ *   4. INVALIDATE THE LIVE SESSIONS. A session holds its own `ModelRuntime`, created when the
+ *      session was built, and that runtime does not know a provider added a minute ago. Pi's
+ *      refusal to switch to an unknown model is swallowed by the session pool into a warning - the
+ *      turn then runs on the OLD model while the picker says the new one. So the sessions are made
+ *      stale instead, and each one is rebuilt at its next turn, which is a moment when throwing the
+ *      session away costs nothing.
+ */
+export declare class ProviderService {
+    private readonly registry;
+    private readonly runtime;
+    private readonly broadcaster;
+    private readonly catalogService;
+    private readonly store;
+    constructor(registry: ProviderRegistry, runtime: AgentRuntime, broadcaster: EventBroadcaster, catalogService: CatalogService, store: Store);
+    /** The providers Super Pi manages, as the browser may see them: no keys, only the fact of one. */
+    list(): Promise<PublicProvider[]>;
+    /**
+     * Adds a provider, or adds a model to one, or updates one.
+     *
+     * ONE CALL, THREE THINGS, because the form collects a provider and a model together and a person
+     * saving a second model under the same provider should not have to retype the API address. The
+     * merge is by id: the provider's fields are replaced by what the form said, and the model with
+     * the same id is replaced while the provider's other models stay.
+     *
+     * THE KEY IS LEFT ALONE UNLESS THE FORM SAYS OTHERWISE. An empty key field means "I did not type
+     * one", not "remove the key": the key is never shown again once it is stored, so an empty field
+     * is the normal state of a form for a provider that already has one. `clearKey` is how a person
+     * asks for it to go.
+     */
+    set(input: unknown): Promise<PublicProvider[]>;
+    /** Removes a provider Super Pi manages, and only one it manages. */
+    remove(providerId: string): Promise<PublicProvider[]>;
+    /**
+     * What has to happen after the files are written, for the change to be REAL rather than pending.
+     *
+     * The catalog is re-read for every live conversation - the same loop the model rules use - rather
+     * than broadcast once without a conversation, because a catalog without a conversation is the
+     * UNFILTERED one, and handing that to a conversation that has model rules would offer it models
+     * those rules forbid.
+     */
+    private afterChange;
+}

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

@@ -0,0 +1,136 @@
+import { KNOWN_APIS, publicProviders, validateProvider } from "../providers.js";
+/**
+ * THE PROVIDERS A PERSON ADDED, as a service.
+ *
+ * The service owns the sequence, and the sequence is the whole point: a provider is not "saved"
+ * when it is in Super Pi's registry, it is saved when Pi can use it. So every change goes through
+ * the same four steps, in this order:
+ *
+ *   1. WRITE PI'S FILES. The definitions go into Pi's `models.json` and the key into Pi's
+ *      `auth.json`, merged into whatever is already there.
+ *   2. WRITE SUPER PI'S REGISTRY. It is the truth source, and it is written AFTER Pi's files so
+ *      that a failure to write them leaves Super Pi claiming nothing it has not done.
+ *   3. INVALIDATE THE CATALOG. Pi's model list is cached - the SDK's is remembered for the life of
+ *      the process and the runtime's has a ten-minute TTL - so a provider added now would not
+ *      appear in the picker until the cache expired. Ten minutes of a picker that cannot see the
+ *      model the person just added is exactly the "decorative control" this project refuses to ship.
+ *   4. INVALIDATE THE LIVE SESSIONS. A session holds its own `ModelRuntime`, created when the
+ *      session was built, and that runtime does not know a provider added a minute ago. Pi's
+ *      refusal to switch to an unknown model is swallowed by the session pool into a warning - the
+ *      turn then runs on the OLD model while the picker says the new one. So the sessions are made
+ *      stale instead, and each one is rebuilt at its next turn, which is a moment when throwing the
+ *      session away costs nothing.
+ */
+export class ProviderService {
+    registry;
+    runtime;
+    broadcaster;
+    catalogService;
+    store;
+    constructor(registry, runtime, broadcaster, catalogService, store) {
+        this.registry = registry;
+        this.runtime = runtime;
+        this.broadcaster = broadcaster;
+        this.catalogService = catalogService;
+        this.store = store;
+    }
+    /** The providers Super Pi manages, as the browser may see them: no keys, only the fact of one. */
+    async list() {
+        return publicProviders(await this.registry.load());
+    }
+    /**
+     * Adds a provider, or adds a model to one, or updates one.
+     *
+     * ONE CALL, THREE THINGS, because the form collects a provider and a model together and a person
+     * saving a second model under the same provider should not have to retype the API address. The
+     * merge is by id: the provider's fields are replaced by what the form said, and the model with
+     * the same id is replaced while the provider's other models stay.
+     *
+     * THE KEY IS LEFT ALONE UNLESS THE FORM SAYS OTHERWISE. An empty key field means "I did not type
+     * one", not "remove the key": the key is never shown again once it is stored, so an empty field
+     * is the normal state of a form for a provider that already has one. `clearKey` is how a person
+     * asks for it to go.
+     */
+    async set(input) {
+        const requested = validateProvider(input);
+        const raw = (input ?? {});
+        const previous = await this.registry.load();
+        const existing = previous.find((provider) => provider.id === requested.id);
+        const apiKey = requested.apiKey
+            ? requested.apiKey
+            : (raw.clearKey === true ? undefined : existing?.apiKey);
+        // A MODEL WITH THE SAME ID IS REPLACED WHERE IT STANDS, not moved to the end: the list a person
+        // sees in the panel is the list they added, and re-ordering it because they edited its first
+        // entry would be a change nobody asked for. A model with a NEW id is appended.
+        const incoming = requested.models[0];
+        const models = !existing
+            ? requested.models
+            : (existing.models.some((model) => model.id === incoming.id)
+                ? existing.models.map((model) => (model.id === incoming.id ? incoming : model))
+                : [...existing.models, incoming]);
+        const merged = {
+            id: requested.id,
+            ...(requested.name ? { name: requested.name } : {}),
+            baseUrl: requested.baseUrl,
+            api: requested.api,
+            ...(apiKey ? { apiKey } : {}),
+            models,
+        };
+        const next = existing
+            ? [...previous.filter((provider) => provider.id !== requested.id), merged]
+            : [...previous, merged];
+        await this.registry.applyToPi(previous, next);
+        try {
+            await this.registry.save(next);
+        }
+        catch (error) {
+            // The registry is the truth source, so a failure to write it means Super Pi no longer knows
+            // what it put into Pi's files. Pi's files are put back the way they were, and the failure is
+            // reported rather than swallowed: a registry that disagrees with Pi's files is a state the
+            // next write would trip over.
+            await this.registry.applyToPi(next, previous).catch(() => undefined);
+            throw error;
+        }
+        await this.afterChange();
+        return publicProviders(next);
+    }
+    /** Removes a provider Super Pi manages, and only one it manages. */
+    async remove(providerId) {
+        const previous = await this.registry.load();
+        const existing = previous.find((provider) => provider.id === providerId);
+        if (!existing)
+            throw new Error(`Super Pi 没有管理供应商「${providerId}」`);
+        const next = previous.filter((provider) => provider.id !== providerId);
+        await this.registry.applyToPi(previous, next);
+        await this.registry.save(next);
+        await this.afterChange();
+        return publicProviders(next);
+    }
+    /**
+     * What has to happen after the files are written, for the change to be REAL rather than pending.
+     *
+     * The catalog is re-read for every live conversation - the same loop the model rules use - rather
+     * than broadcast once without a conversation, because a catalog without a conversation is the
+     * UNFILTERED one, and handing that to a conversation that has model rules would offer it models
+     * those rules forbid.
+     */
+    async afterChange() {
+        this.runtime.invalidateCatalog?.();
+        this.runtime.bumpModelEpoch?.();
+        for (const conversation of this.store.snapshot().conversations) {
+            if (conversation.archivedAt)
+                continue;
+            try {
+                await this.catalogService.broadcastCatalog(conversation.model, conversation.id);
+            }
+            catch (error) {
+                console.warn(`供应商已保存，刷新会话 ${conversation.id} 的模型目录失败：${String(error)}`);
+            }
+        }
+        // The settings panel's OWN list, which is unfiltered and therefore has to be asked for
+        // separately. Without this the person who just added a provider would not see their own model
+        // in the default-model dropdown until they closed the window and opened it again.
+        await this.catalogService.broadcastAllCatalog?.();
+        this.broadcaster.broadcast({ type: "providers.list", providers: await this.list(), apis: [...KNOWN_APIS] });
+    }
+}

package/dist/server/command-handler.d.ts

@@ -4,6 +4,7 @@ import type { ConversationService } from "./application/conversation-service.js"
 import type { RunService } from "./application/run-service.js";
 import type { ExtensionUiService } from "./application/extension-ui-service.js";
 import type { CatalogService } from "./application/catalog-service.js";
+import type { ProviderService } from "./application/provider-service.js";
 import type { TerminalService } from "./terminal.js";
 export type SocketSender = (event: ServerEvent) => void;
 /**
@@ -17,6 +18,13 @@ export declare class CommandHandler {
     private readonly catalogService;
     /** Path to the Super Pi repository root, used to spawn the restart script. */
     private readonly rootDir?;
+    /**
+     * The providers a person added through the settings window.
+     *
+     * Optional because the command handler is constructed by tests that do not care about providers,
+     * and a missing service has to say so rather than take the whole handler down.
+     */
+    private readonly providerService?;
     /**
      * The built-in terminal service.
      *
@@ -25,7 +33,14 @@ export declare class CommandHandler {
     private readonly terminalService?;
     constructor(workspaceService: WorkspaceService, conversationService: ConversationService, runService: RunService, extensionUiService: ExtensionUiService, catalogService: CatalogService, terminalService?: TerminalService, 
     /** Path to the Super Pi repository root, used to spawn the restart script. */
-    rootDir?: string | undefined);
+    rootDir?: string | undefined, 
+    /**
+     * The providers a person added through the settings window.
+     *
+     * Optional because the command handler is constructed by tests that do not care about providers,
+     * and a missing service has to say so rather than take the whole handler down.
+     */
+    providerService?: ProviderService | undefined);
     /**
      * Processes a client command.
      *

package/dist/server/command-handler.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { join } from "node:path";
+import { KNOWN_APIS } from "./providers.js";
 import { packageUpdateArgs } from "./update.js";
 /**
  * Routes client commands to appropriate application services and converts results or errors.
@@ -11,6 +12,7 @@ export class CommandHandler {
     extensionUiService;
     catalogService;
     rootDir;
+    providerService;
     /**
      * The built-in terminal service.
      *
@@ -19,13 +21,21 @@ export class CommandHandler {
     terminalService;
     constructor(workspaceService, conversationService, runService, extensionUiService, catalogService, terminalService, 
     /** Path to the Super Pi repository root, used to spawn the restart script. */
-    rootDir) {
+    rootDir, 
+    /**
+     * The providers a person added through the settings window.
+     *
+     * Optional because the command handler is constructed by tests that do not care about providers,
+     * and a missing service has to say so rather than take the whole handler down.
+     */
+    providerService) {
         this.workspaceService = workspaceService;
         this.conversationService = conversationService;
         this.runService = runService;
         this.extensionUiService = extensionUiService;
         this.catalogService = catalogService;
         this.rootDir = rootDir;
+        this.providerService = providerService;
         this.terminalService = terminalService;
     }
     /**
@@ -69,6 +79,29 @@ export class CommandHandler {
             await this.catalogService.setDefaultModel(command.model);
             return;
         }
+        // THE PROVIDERS A PERSON ADDED. The list is answered to the ASKING socket only - it is a panel's
+        // private list, and broadcasting it would put a provider's API address in every other tab's state
+        // for no gain. The set and the remove broadcast the new list themselves, because everybody who
+        // has the settings window open has to see the change.
+        if (command.type === "providers.set") {
+            if (!this.providerService)
+                throw new Error("供应商功能不可用");
+            await this.providerService.set(command.provider);
+            return;
+        }
+        if (command.type === "providers.remove") {
+            if (!this.providerService)
+                throw new Error("供应商功能不可用");
+            await this.providerService.remove(command.providerId);
+            return;
+        }
+        if (command.type === "providers.fetch") {
+            if (!this.providerService)
+                throw new Error("供应商功能不可用");
+            if (sendToSocket)
+                sendToSocket({ type: "providers.list", providers: await this.providerService.list(), apis: [...KNOWN_APIS] });
+            return;
+        }
         if (command.type === "workspace.create") {
             return await this.workspaceService.createWorkspace(command.name, command.path);
         }

package/dist/server/index.js

@@ -16,6 +16,8 @@ import { SubagentRunRecorder } from "./subagent-runs.js";
 import { WorkflowEngine } from "./workflow-engine.js";
 import { ExtensionUiService } from "./application/extension-ui-service.js";
 import { CatalogService } from "./application/catalog-service.js";
+import { ProviderService } from "./application/provider-service.js";
+import { ProviderRegistry } from "./providers.js";
 import { RunService } from "./application/run-service.js";
 import { ConversationService } from "./application/conversation-service.js";
 import { WorkspaceService } from "./application/workspace-service.js";
@@ -178,6 +180,15 @@ const onDirsChanged = (dirs) => {
     workspaceService.setAgentsDir(dirs);
 };
 const catalogService = new CatalogService(runtime, broadcaster, initialAgentDirs, store, rootDir, onDirsChanged);
+/**
+ * The providers a person added through the settings window.
+ *
+ * The registry lives in Super Pi's own data directory and holds the API keys; Pi's `models.json` and
+ * `auth.json` are written from it, so a provider added here is a provider Pi can use - in a session,
+ * in a spawned Pi, and in the terminal.
+ */
+const providerRegistry = new ProviderRegistry(dataDir);
+const providerService = new ProviderService(providerRegistry, runtime, broadcaster, catalogService, store);
 const runService = new RunService(store, runtime, subagents, broadcaster, extensionUiService, initialAgentDirs, workflows);
 runService.setMemory(memory);
 const conversationService = new ConversationService(store, runtime, subagents, broadcaster, catalogService, runService, extensionUiService, initialAgentDirs);
@@ -216,6 +227,7 @@ const serverContext = {
     runService,
     extensionUiService,
     catalogService,
+    providerService,
     execService,
     toolRegistry,
     toolRunner,
@@ -223,7 +235,7 @@ const serverContext = {
     terminalEnabled: () => terminalService.enabled,
     terminalDisabledReason: () => terminalDisabledReason(),
 };
-const commandHandler = new CommandHandler(workspaceService, conversationService, runService, extensionUiService, catalogService, terminalService, rootDir);
+const commandHandler = new CommandHandler(workspaceService, conversationService, runService, extensionUiService, catalogService, terminalService, rootDir, providerService);
 // ------------------------------------------------------------- Lifecycle & shutdown
 let shutdownPromise;
 async function closeHttpServer() {

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

@@ -78,6 +78,15 @@ export declare class PiSessionPool {
      * knows what one looks like.
      */
     private readonly mintCapability;
+    /**
+     * How many times the set of models Pi knows about has changed.
+     *
+     * Injected rather than imported for the same reason the capability minting is: the pool needs to
+     * know WHEN a session is stale, and the caller knows what changed. A provider added through the
+     * settings window makes every live session unable to reach the new model, and the next turn is
+     * where that gets fixed.
+     */
+    private readonly modelEpoch;
     private readonly sessions;
     constructor(
     /** Where Pi keeps its session files. */
@@ -104,7 +113,16 @@ export declare class PiSessionPool {
      * does not have to know what a capability is - it needs to know WHEN one is needed, and the caller
      * knows what one looks like.
      */
-    mintCapability?: (conversationId: string) => string);
+    mintCapability?: (conversationId: string) => string, 
+    /**
+     * How many times the set of models Pi knows about has changed.
+     *
+     * Injected rather than imported for the same reason the capability minting is: the pool needs to
+     * know WHEN a session is stale, and the caller knows what changed. A provider added through the
+     * settings window makes every live session unable to reach the new model, and the next turn is
+     * where that gets fixed.
+     */
+    modelEpoch?: () => number);
     /**
      * 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

@@ -48,6 +48,7 @@ export class PiSessionPool {
     onSessionDestroyed;
     factory;
     mintCapability;
+    modelEpoch;
     sessions = new Map();
     constructor(
     /** Where Pi keeps its session files. */
@@ -74,13 +75,23 @@ export class PiSessionPool {
      * does not have to know what a capability is - it needs to know WHEN one is needed, and the caller
      * knows what one looks like.
      */
-    mintCapability = () => "") {
+    mintCapability = () => "", 
+    /**
+     * How many times the set of models Pi knows about has changed.
+     *
+     * Injected rather than imported for the same reason the capability minting is: the pool needs to
+     * know WHEN a session is stale, and the caller knows what changed. A provider added through the
+     * settings window makes every live session unable to reach the new model, and the next turn is
+     * where that gets fixed.
+     */
+    modelEpoch = () => 0) {
         this.sessionDir = sessionDir;
         this.repositoryRoot = repositoryRoot;
         this.agentDir = agentDir;
         this.onSessionDestroyed = onSessionDestroyed;
         this.factory = factory;
         this.mintCapability = mintCapability;
+        this.modelEpoch = modelEpoch;
     }
     /**
      * The session for a conversation, built if there is none and REPLACED if the live one is stale.
@@ -227,6 +238,7 @@ export class PiSessionPool {
             tools: request.tools,
             excludeTools: request.excludeTools,
             extensions: superPiExtensionPaths(this.repositoryRoot),
+            modelEpoch: this.modelEpoch(),
         };
     }
     /**

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

@@ -129,6 +129,16 @@ export interface SessionFingerprint {
     excludeTools: string[] | undefined;
     /** Which of Super Pi's own extensions were mounted. */
     extensions: string[];
+    /**
+     * How many times the set of models Pi knows about has changed.
+     *
+     * NOT THE MODEL, BUT THE WORLD THE MODEL LIVES IN. A session's `ModelRuntime` is built with it and
+     * does not learn about a provider added afterwards, so a session that keeps running on the old
+     * runtime cannot switch to a model that only exists in the new one - and Pi's refusal to switch is
+     * swallowed into a warning, which would leave the turn running a model the picker does not name.
+     * The counter makes such a session stale, and it is rebuilt at its next turn.
+     */
+    modelEpoch: number;
 }
 /**
  * Fingerprints are compared by VALUE, and this is where that comparison is spelled out.

package/dist/server/pi-session.js

@@ -185,6 +185,8 @@ export function sameFingerprint(a, b) {
         return false;
     if (!sameSet(a.extensions, b.extensions))
         return false;
+    if (a.modelEpoch !== b.modelEpoch)
+        return false;
     return true;
 }
 function sameSet(a, b) {
@@ -343,8 +345,17 @@ async function resolveSessionManager(sdk, creation) {
  * file goes out of its way not to do for a path it can derive. The derivation is Pi's own default:
  * `~/.pi/agent`, with the home directory taken from the environment rather than from `os.homedir()`,
  * because on Windows the two disagree often enough to matter.
+ *
+ * `PI_CODING_AGENT_DIR` WINS, exactly as it wins in Pi (`core/config.ts:getAgentDir`). A person who
+ * set it expects Pi to read its whole configuration from there, and this function used to disagree
+ * with Pi about it: Pi's model runtime read `models.json` from that directory while the session's
+ * resource loader read the skills from `~/.pi/agent`. Two halves of one Pi pointed at two
+ * directories, and only one of them was the one the person had configured.
  */
 function defaultAgentDir() {
+    const configured = process.env.PI_CODING_AGENT_DIR?.trim();
+    if (configured)
+        return configured;
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
     return home ? join(home, ".pi", "agent") : join(".pi", "agent");
 }