@evandu/super-pi 0.1.104 → 0.1.106

package/dist/server/runtime.js

@@ -22,6 +22,7 @@ import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_END
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
 import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractPartialResultText, extractToolResultText, readQuestionCall } from "./tool-calls.js";
+import { toolTargetPath } from "./file-changes.js";
 const traceLatency = (conversationId, phase, startedAt, extra = "") => {
     if (process.env.SUPER_PI_TRACE_LATENCY !== "1")
         return;
@@ -342,6 +343,17 @@ export class PiRpcRuntime {
      * otherwise be re-imported on every picker open.
      */
     sdkCatalogPromise;
+    /**
+     * Bumped whenever the set of models Pi knows about changes.
+     *
+     * A live session holds its own `ModelRuntime`, built when the session was built, and that runtime
+     * does not know about a provider added afterwards. Pi's refusal to switch to a model its runtime
+     * does not have is swallowed by the session pool into a warning, so the turn would go on running
+     * the OLD model while the picker said the new one - a control that lies. The sessions are made
+     * STALE by this counter instead: each one is rebuilt at its next turn, which is a moment when
+     * throwing a session away costs nothing, and the new one is built with a runtime that knows.
+     */
+    modelEpoch = 0;
     /** Latches the "no extension on disk" warning, so it is said once rather than once per turn. */
     warnedMissingExtension = false;
     /** Latches the "Pi's SDK is not installed" warning, for the same reason. */
@@ -429,7 +441,7 @@ export class PiRpcRuntime {
             // ABOUT that session and stop being true with it.
             this.sessionHosts.delete(conversationId);
             this.reportedSessionFiles.delete(conversationId);
-        }, options.sessionFactory ?? createPiSession, (conversationId) => mintCapability(conversationId));
+        }, options.sessionFactory ?? createPiSession, (conversationId) => mintCapability(conversationId), () => this.modelEpoch);
     }
     /**
      * The configuration of the session that was built for a conversation, for tests to inspect.
@@ -719,6 +731,7 @@ export class PiRpcRuntime {
         const queue = new TurnQueue();
         const handlers = {
             onToolCall: input.onToolCall,
+            onFileWrite: input.onFileWrite,
             onToolUpdate: input.onToolUpdate,
             onToolPreparing: input.onToolPreparing,
             onToolEnd: input.onToolEnd,
@@ -1052,7 +1065,7 @@ export class PiRpcRuntime {
      * Still used for the memory review, the knowledge reranker, and as the fallback when Pi's SDK is not
      * installed. The main conversation path does NOT come here - see `answer`.
      */
-    async *answerOneShot({ conversation, prompt, signal, cwd, host, onPiQueue, onSteerDelivered, onUserEntry, onSessionFile, onToolCall, onToolUpdate, onToolPreparing, onToolEnd, onThinking, onThinkingEnd, images, memoryReview, memorySourceConversationId, knowledgeRerank }) {
+    async *answerOneShot({ conversation, prompt, signal, cwd, host, onPiQueue, onSteerDelivered, onUserEntry, onSessionFile, onToolCall, onFileWrite, onToolUpdate, onToolPreparing, onToolEnd, onThinking, onThinkingEnd, images, memoryReview, memorySourceConversationId, knowledgeRerank }) {
         const latencyStartedAt = performance.now();
         traceLatency(conversation.id, "answer.begin", latencyStartedAt);
         await mkdir(this.sessionDir, { recursive: true });
@@ -1379,6 +1392,19 @@ export class PiRpcRuntime {
                         catch (error) {
                             console.warn(`PiRpcRuntime: the tool call handler threw: ${error instanceof Error ? error.message : "unknown error"}`);
                         }
+                        // THE FILE-WRITING CALL, announced before it runs. This is the ONLY moment the old content
+                        // is still on the disk, so this is where a baseline has to be taken - and it is taken by a
+                        // listener that does its own I/O, off the drain loop's path, because a disk read between
+                        // yields would stall the stream.
+                        const writePath = toolTargetPath(name, record.args);
+                        if (writePath) {
+                            try {
+                                onFileWrite?.(writePath, name, record.toolCallId ?? undefined);
+                            }
+                            catch (error) {
+                                console.warn(`PiRpcRuntime: the file-write handler threw: ${error instanceof Error ? error.message : "unknown error"}`);
+                            }
+                        }
                         continue;
                     }
                     if (record.type === "tool_execution_end") {
@@ -2242,6 +2268,32 @@ export class PiRpcRuntime {
         }
         return answer;
     }
+    /**
+     * Throws away every cached answer about the models Pi offers.
+     *
+     * Called when the model list itself changes - which today means a person added a provider
+     * through the settings window. The caches are three deep and all three have to go: the TTL map
+     * (ten minutes), the in-flight map (a read that is already running would answer with the old
+     * list), and the SDK catalog, which is remembered for the life of the process because it holds
+     * objects that read the auth store and the model store from disk - and those files are exactly
+     * what just changed.
+     */
+    invalidateCatalog() {
+        this.catalogs.clear();
+        this.pendingCatalogs.clear();
+        this.sdkCatalogPromise = undefined;
+    }
+    /**
+     * Makes every live session stale, so the next turn builds one that knows the current models.
+     *
+     * WHY A COUNTER AND NOT A REBUILD. Rebuilding a session means throwing it away and reading its
+     * transcript back, and a turn may be RUNNING right now. The counter is read by the session pool
+     * as part of the fingerprint, so each session notices at its next acquire - between turns, where
+     * a rebuild is free.
+     */
+    bumpModelEpoch() {
+        this.modelEpoch += 1;
+    }
     /**
      * The model/thinking catalog, from Pi, cached.
      *

package/dist/server/server-context.d.ts

@@ -7,6 +7,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 { ExecService } from "./exec-service.js";
 import type { ToolRegistry } from "./tool-registry.js";
 import type { ToolRunner } from "./tool-runner.js";
@@ -49,9 +50,23 @@ export interface ServerContext {
     runService: RunService;
     extensionUiService: ExtensionUiService;
     catalogService: CatalogService;
+    /** The providers a person added through the settings window. */
+    providerService: ProviderService;
     execService: ExecService;
     toolRegistry: ToolRegistry;
     toolRunner: ToolRunner;
+    /**
+     * WHAT THE AGENT CHANGED, and what each file looked like before.
+     *
+     * The tracker is here because TWO layers need it: the run service writes to it (a write tool is
+     * announced, so the "before" is captured) and the HTTP layer reads from it (a diff request asks for
+     * the "before" of one file). Putting it in the context rather than inside either service is what
+     * keeps it ONE tracker - two trackers would be two answers to "what did the agent change", and only
+     * one of them would have the baselines.
+     */
+    fileChanges?: import("./file-changes.js").FileChangeTracker;
+    /** Shared file indexes: the HTTP layer starts them lazily and write paths refresh known entries. */
+    fileIndexes?: Map<string, import("./file-index.js").FileIndex>;
     /** Absent only if construction failed; a runtime with no Pi reports itself through `available`. */
     toolLlm?: import("./tool-llm.js").ToolLlmService;
     /**

package/dist/server/types.d.ts

@@ -377,6 +377,29 @@ export type ModelOption = ModelSelection & {
  * honest answer is "the list could not be read". `fetchedAt` travels with the value so a stale
  * cache is visible rather than silent.
  */
+/**
+ * A provider a person added through the settings window, as the BROWSER sees it.
+ *
+ * The API key is a FACT here and not a value: `hasKey` says whether one is stored, and the key
+ * itself never leaves the server. It is in Super Pi's own registry and in Pi's `auth.json`, both of
+ * them files with restrictive permissions, and in neither the state snapshot nor any event.
+ */
+export type PublicProviderModel = {
+    id: string;
+    name: string;
+    reasoning: boolean;
+    imageInput: boolean;
+    contextWindow: number;
+    maxTokens: number;
+};
+export type PublicProvider = {
+    id: string;
+    name: string;
+    baseUrl: string;
+    api: string;
+    hasKey: boolean;
+    models: PublicProviderModel[];
+};
 export type ModelCatalog = {
     source: "pi" | "unavailable";
     models: ModelOption[];
@@ -874,6 +897,54 @@ export type ClientCommandBody =
     type: "model.rules.set";
     rules: ModelFilterRule[];
 }
+/**
+ * Adds a provider, or adds a model to one, or updates one.
+ *
+ * The key is OPTIONAL and its absence means "keep the stored one": the key is never shown again
+ * once it is saved, so an empty field is the normal state of the form for a provider that already
+ * has one. `clearKey` is how a person asks for it to be removed.
+ */
+ | {
+    type: "providers.set";
+    provider: {
+        id: string;
+        name?: string;
+        baseUrl: string;
+        api: string;
+        apiKey?: string;
+        clearKey?: boolean;
+        models: {
+            id: string;
+            name?: string;
+            reasoning?: boolean;
+            imageInput?: boolean;
+            contextWindow?: number;
+            maxTokens?: number;
+            supportsDeveloperRole?: boolean;
+            supportsReasoningEffort?: boolean;
+        }[];
+    };
+}
+/** Removes a provider Super Pi manages. One it does not manage is refused. */
+ | {
+    type: "providers.remove";
+    providerId: string;
+}
+/**
+ * Removes ONE model from a provider, leaving the provider and its other models alone.
+ *
+ * Separate from `providers.remove` because a provider is a GROUP of models sharing one address
+ * and one key: taking one model out must not cost the others their credential.
+ */
+ | {
+    type: "providers.removeModel";
+    providerId: string;
+    modelId: string;
+}
+/** Asks for the providers Super Pi manages. The answer carries no key. */
+ | {
+    type: "providers.fetch";
+}
 /**
  * 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
@@ -1210,9 +1281,69 @@ export type MountedToolSummary = {
     description?: string;
     enabled: boolean;
 };
+/**
+ * A file the agent changed, as the Files panel learns about it.
+ *
+ * `path` is workspace-relative and `/`-separated, the same spelling every other file path uses on the
+ * wire. `baseline` is the content BEFORE the agent's write, or `null` when there was none - which is
+ * how a NEW file is told from an EDITED one, and the two are different things to a reader.
+ *
+ * `baselineUnknown` says the "before" could not be read, as opposed to not existing. A diff view that
+ * shows an empty "before" for a file that existed is a lie, and this flag is what keeps it from being
+ * one.
+ */
+export type ChangedFile = {
+    path: string;
+    /** The content before the agent wrote it, or `null` when the file did not exist then. */
+    baseline: string | null;
+    /** True when the baseline is missing because it could not be read, not because the file was new. */
+    baselineUnknown?: boolean;
+    /** The conversation the change belongs to, so a workspace's changes can be attributed to a session. */
+    conversationId?: string;
+    /** When it happened, so the panel can order a turn's changes the way they happened. */
+    at: number;
+};
 export type ServerEvent = {
     type: "tools.updated";
     tools: MountedToolSummary[];
+}
+/**
+ * THE AGENT CHANGED THESE FILES.
+ *
+ * WHY THIS EXISTS. The Files panel could browse the workspace but could not show a CHANGE, and a panel
+ * that cannot show a change is a browser rather than a workbench: the user asked for the opposite - being
+ * able to see the files is what makes the agent's edits reviewable. The server already knew which files
+ * the agent wrote (the tool call names the path) and the knowledge went no further than one line on a
+ * card, so a file the agent had rewritten looked exactly like a file it had never touched.
+ *
+ * A SNAPSHOT rather than a delta, like every other state-bearing event here: the client replaces its
+ * list with this one, so a browser that missed an event rebuilds the list from the next one rather than
+ * accumulating a partial truth.
+ *
+ * `dropped` says how many baselines were evicted because the per-workspace cap was reached. It is
+ * reported rather than hidden, because a list that is shorter than the agent's actual work - with no
+ * explanation - reads as "the agent only changed these" and is wrong.
+ */
+ | {
+    type: "files.changed";
+    workspaceId: string;
+    changes: ChangedFile[];
+    dropped: number;
+} | {
+    type: "files.index";
+    workspaceId: string;
+    version: number;
+    changed: {
+        path: string;
+        kind: "file" | "directory";
+        size: number | null;
+        mtimeMs: number | null;
+        etag: string | null;
+        text: boolean | null;
+    }[];
+    removed: string[];
+    complete: boolean;
+    skipped: string[];
 } | {
     type: "operation.result";
     requestId: string;
@@ -1330,6 +1461,18 @@ export type ServerEvent = {
     type: "model.catalog.all";
     catalog: ModelCatalog;
 }
+/**
+ * The providers Super Pi manages. Sent when they change, and when a client connects.
+ *
+ * `apis` travels with them so the form's API-type list has ONE source of truth: the list of
+ * adapters Pi ships is a fact about the Pi that is installed, and a copy of it in the browser
+ * would be a copy that goes stale.
+ */
+ | {
+    type: "providers.list";
+    providers: PublicProvider[];
+    apis: string[];
+}
 /**
  * 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.104",
+  "version": "0.1.106",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -87,6 +87,10 @@
     "scripts/tool-calls.test.mjs",
     "scripts/files-api.test.mjs",
     "scripts/files-missing-path.test.mjs",
+    "scripts/file-changes.test.mjs",
+    "scripts/file-index.test.mjs",
+    "scripts/file-content-search.test.mjs",
+    "scripts/file-diff-client.test.mjs",
     "scripts/task-tool.test.mjs",
     "scripts/fork-server.test.mjs",
     "scripts/styles-no-dangling.test.mjs",
@@ -94,6 +98,8 @@
     "scripts/agent-config-regression.test.mjs",
     "scripts/model-filter.test.mjs",
     "scripts/settings-default-model.test.mjs",
+    "scripts/provider-registry.test.mjs",
+    "scripts/provider-pi-reads.test.mjs",
     "scripts/active-memory.test.mjs",
     "scripts/knowledge-base.test.mjs",
     "scripts/tool-runner.test.mjs",
@@ -128,6 +134,9 @@
     "scripts/session-context-menu-browser.test.mjs",
     "scripts/tool-call-blocks-browser.test.mjs",
     "scripts/files-tab-browser.test.mjs",
+    "scripts/file-quickopen-browser.test.mjs",
+    "scripts/file-content-search-browser.test.mjs",
+    "scripts/file-changes-browser.test.mjs",
     "scripts/msg-tabs-browser.test.mjs",
     "scripts/tabs-on-top-browser.test.mjs",
     "scripts/subagent-source.test.mjs",
@@ -140,6 +149,7 @@
     "scripts/theme-switch-state.test.mjs",
     "scripts/settings-window-structure.test.mjs",
     "scripts/settings-model-browser.test.mjs",
+    "scripts/provider-browser.test.mjs",
     "scripts/file-tab-selected-contrast.test.mjs",
     "scripts/help-window.test.mjs",
     "scripts/composer-regression-browser.test.mjs",
@@ -151,8 +161,11 @@
   ],
   "dependencies": {
     "@earendil-works/pi-coding-agent": "^0.86.1",
+    "@types/diff": "^5.2.3",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",
+    "diff": "^5.2.2",
+    "fuse.js": "^7.5.0",
     "node-pty": "^1.2.0-beta.15",
     "ws": "latest"
   },