@psnext/slingcli 2.5.20260722-2 → 2.5.20260722-3

package/node_modules/@earendil-works/pi-coding-agent/dist/core/model-runtime.js

@@ -32,7 +32,7 @@ export class ModelRuntime {
     extensionProviders = new Map();
     compositionErrors = new Map();
     modelsPath;
-    allowModelNetwork;
+    modelNetworkEnabled;
     config;
     snapshot = {
         all: [],
@@ -43,11 +43,11 @@ export class ModelRuntime {
     };
     availabilityRefresh;
     availabilityError;
-    constructor(credentials, config, modelsPath, modelsStore, providers, allowModelNetwork) {
+    constructor(credentials, config, modelsPath, modelsStore, providers, modelNetworkEnabled) {
         this.credentials = credentials;
         this.config = config;
         this.modelsPath = modelsPath;
-        this.allowModelNetwork = allowModelNetwork;
+        this.modelNetworkEnabled = modelNetworkEnabled;
         this.defaultBuiltins = new Map(providers.map((provider) => [provider.id, provider]));
         for (const [providerId, provider] of this.defaultBuiltins)
             this.builtins.set(providerId, provider);
@@ -64,16 +64,19 @@ export class ModelRuntime {
                 : new InMemoryCodingAgentModelsStore());
         const providers = builtinProviderCatalog
             .builtinProviders()
-            .map((provider) => provider.id === "radius" ? provider : withRemoteCatalog(provider, options.catalogBaseUrl));
-        const runtime = new ModelRuntime(credentials, config, modelsPath, modelsStore, providers, options.allowModelNetwork ?? process.env.PI_OFFLINE === undefined);
+            .map((provider) => provider.id === "radius"
+            ? provider
+            : withRemoteCatalog(provider, options.catalogBaseUrl, builtinProviderCatalog.getBuiltinModelDataUrl(provider.id)));
+        const runtime = new ModelRuntime(credentials, config, modelsPath, modelsStore, providers, process.env.PI_OFFLINE === undefined);
         runtime.configureRadiusProviders();
         runtime.rebuildProviders();
-        const controller = new AbortController();
-        const timeout = runtime.allowModelNetwork
+        const refreshFromNetwork = runtime.modelNetworkEnabled && options.allowModelNetwork === true;
+        const controller = refreshFromNetwork ? new AbortController() : undefined;
+        const timeout = controller
             ? setTimeout(() => controller.abort(), options.modelRefreshTimeoutMs ?? 15_000)
             : undefined;
         try {
-            await runtime.refresh({ allowNetwork: runtime.allowModelNetwork, signal: controller.signal });
+            await runtime.refresh({ allowNetwork: refreshFromNetwork, signal: controller?.signal });
         }
         finally {
             if (timeout)
@@ -270,7 +273,7 @@ export class ModelRuntime {
             },
         };
     }
-    async setRuntimeApiKey(providerId, apiKey) {
+    async setRuntimeApiKey(providerId, apiKey, refreshOptions = {}) {
         this.credentials.setRuntimeApiKey(providerId, apiKey);
         const auth = new Map(this.snapshot.auth).set(providerId, { type: "api_key", source: "runtime API key" });
         const configuredProviders = new Set(this.snapshot.configuredProviders).add(providerId);
@@ -282,11 +285,11 @@ export class ModelRuntime {
             storedProviders,
             available: this.snapshot.all.filter((model) => configuredProviders.has(model.provider)),
         };
-        await this.refresh({ allowNetwork: this.allowModelNetwork });
+        await this.refresh(refreshOptions);
     }
     async removeRuntimeApiKey(providerId) {
         this.credentials.removeRuntimeApiKey(providerId);
-        await this.refresh({ allowNetwork: this.allowModelNetwork });
+        await this.refresh({ allowNetwork: this.modelNetworkEnabled });
     }
     listCredentials() {
         return this.credentials.list();
@@ -347,25 +350,25 @@ export class ModelRuntime {
     }
     async login(providerId, type, interaction) {
         const credential = await this.models.login(providerId, type, interaction);
-        await this.refresh({ allowNetwork: this.allowModelNetwork });
+        await this.refresh({ allowNetwork: this.modelNetworkEnabled });
         return credential;
     }
     async logout(providerId) {
         await this.models.logout(providerId);
         // Reset credential-dependent compatibility projections before the unconfigured provider is skipped by refresh.
         this.recomposeProvider(providerId);
-        await this.refresh({ allowNetwork: this.allowModelNetwork });
+        await this.refresh({ allowNetwork: this.modelNetworkEnabled });
     }
     async reloadConfig() {
         this.config = await ModelConfig.load(this.modelsPath);
         this.configureRadiusProviders();
         this.rebuildProviders();
-        await this.refresh({ allowNetwork: this.allowModelNetwork });
+        await this.refresh({ allowNetwork: this.modelNetworkEnabled });
     }
     async refresh(options = {}) {
         const refreshOptions = {
             ...options,
-            allowNetwork: options.allowNetwork ?? this.allowModelNetwork,
+            allowNetwork: options.allowNetwork ?? this.modelNetworkEnabled,
         };
         // Published pi-ai builds before ModelsStore returned void and accepted a provider ID.
         // The fallback keeps source-mode CLI tests working without rebuilding workspace dependencies.

package/node_modules/@earendil-works/pi-coding-agent/dist/core/project-trust.js

@@ -2,7 +2,7 @@ import { CONFIG_DIR_NAME } from "../config.js";
 import { emitProjectTrustEvent } from "./extensions/runner.js";
 import { getProjectTrustOptions, hasTrustRequiringProjectResources, } from "./trust-manager.js";
 function formatProjectTrustPrompt(cwd) {
-    return `Trust project folder?\n${cwd}\n\nThis allows sling to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
+    return `Trust project folder?\n${cwd}\n\nThis allows pi to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
 }
 async function selectProjectTrustOption(cwd, ctx) {
     const options = getProjectTrustOptions(cwd, { includeSessionOnly: true });

package/node_modules/@earendil-works/pi-coding-agent/dist/core/remote-catalog-provider.js

@@ -1,3 +1,4 @@
+import { stat } from "node:fs/promises";
 import { VERSION } from "../config.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
 const DEFAULT_CATALOG_BASE_URL = "https://pi.dev";
@@ -27,8 +28,17 @@ function parseCatalog(providerId, value) {
         .filter((entry) => typeof entry === "object" && entry !== null && "id" in entry)
         .map((model) => ({ ...model, provider: providerId }));
 }
+function remoteModels(entry, localLastModified) {
+    if (!entry)
+        return [];
+    if (localLastModified !== undefined &&
+        (entry.lastModified === undefined || entry.lastModified <= localLastModified)) {
+        return [];
+    }
+    return entry.models;
+}
 /** Add a persisted pi.dev catalog overlay to a static built-in provider. */
-export function withRemoteCatalog(provider, catalogBaseUrl = DEFAULT_CATALOG_BASE_URL) {
+export function withRemoteCatalog(provider, catalogBaseUrl = DEFAULT_CATALOG_BASE_URL, localCatalogUrl) {
     let dynamicModels = [];
     let inflightRefresh;
     return {
@@ -37,13 +47,16 @@ export function withRemoteCatalog(provider, catalogBaseUrl = DEFAULT_CATALOG_BAS
         refreshModels: (context) => {
             inflightRefresh ??= (async () => {
                 try {
+                    const localLastModified = localCatalogUrl
+                        ? await stat(localCatalogUrl).then((value) => value.mtimeMs, () => undefined)
+                        : undefined;
                     const stored = await context.store.read();
-                    if (stored)
-                        dynamicModels = stored.models.filter((model) => model.provider === provider.id);
+                    dynamicModels = remoteModels(stored, localLastModified).filter((model) => model.provider === provider.id);
                     if (!context.allowNetwork || context.signal?.aborted)
                         return;
                     if (!context.force &&
                         stored?.checkedAt !== undefined &&
+                        stored.lastModified !== undefined &&
                         Date.now() - stored.checkedAt < REMOTE_CATALOG_REFRESH_INTERVAL_MS) {
                         return;
                     }
@@ -59,18 +72,24 @@ export function withRemoteCatalog(provider, catalogBaseUrl = DEFAULT_CATALOG_BAS
                         return;
                     const checkedAt = Date.now();
                     if (response.status === 404 || response.status === 501) {
-                        await context.store.write({ models: dynamicModels, checkedAt });
+                        await context.store.write({ ...(stored ?? { models: [] }), checkedAt, lastModified: 0 });
                         return;
                     }
                     if (!response.ok) {
-                        await context.store.write({ models: dynamicModels, checkedAt });
+                        await context.store.write({ ...(stored ?? { models: [] }), checkedAt });
                         throw new Error(`Model catalog request failed for ${provider.id}: ${response.status}`);
                     }
                     const refreshed = parseCatalog(provider.id, await response.json());
+                    const lastModified = Date.parse(response.headers.get("last-modified") ?? "");
                     if (context.signal?.aborted)
                         return;
-                    dynamicModels = refreshed;
-                    await context.store.write({ models: refreshed, checkedAt });
+                    const entry = {
+                        models: refreshed,
+                        checkedAt,
+                        lastModified: Number.isNaN(lastModified) ? 0 : lastModified,
+                    };
+                    dynamicModels = remoteModels(entry, localLastModified);
+                    await context.store.write(entry);
                 }
                 finally {
                     inflightRefresh = undefined;

package/node_modules/@earendil-works/pi-coding-agent/dist/core/sdk.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
-import { Agent } from "@earendil-works/pi-agent-core";
-import { clampThinkingLevel } from "@earendil-works/pi-ai/compat";
+import { Agent, setDefaultStreamFn } from "@earendil-works/pi-agent-core";
+import { clampThinkingLevel, streamSimple } from "@earendil-works/pi-ai/compat";
 import { getAgentDir } from "../config.js";
 import { resolvePath } from "../utils/paths.js";
 import { AgentSession } from "./agent-session.js";
@@ -15,6 +15,10 @@ import { getDefaultSessionDir, SessionManager } from "./session-manager.js";
 import { SettingsManager } from "./settings-manager.js";
 import { time } from "./timings.js";
 import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue, } from "./tools/index.js";
+// Preserve the pre-0.81 fallback for extensions that construct Agent instances
+// or invoke low-level agent loops without supplying streamFn. Agent core remains
+// provider-agnostic and does not import pi-ai/compat itself.
+setDefaultStreamFn(streamSimple);
 // Re-exports
 export * from "./agent-session-runtime.js";
 export { withFileMutationQueue, 

package/node_modules/@earendil-works/pi-coding-agent/dist/core/session-manager.js

@@ -1,4 +1,4 @@
-import { uuidv7 } from "@earendil-works/pi-agent-core";
+import { uuidv7 } from "@earendil-works/pi-ai";
 import { randomUUID } from "crypto";
 import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readSync, statSync, writeFileSync, } from "fs";
 import { readdir, stat } from "fs/promises";
@@ -253,6 +253,15 @@ export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
     return sessionDir;
 }
 const SESSION_READ_BUFFER_SIZE = 1024 * 1024;
+const SESSION_HEADER_READ_BUFFER_SIZE = 4096;
+/** Bound synchronous header discovery while allowing large cwd and custom metadata fields. */
+const MAX_SESSION_HEADER_SCAN_BYTES = 1024 * 1024;
+class SessionHeaderScanLimitError extends Error {
+    constructor(filePath) {
+        super(`Session header exceeds ${MAX_SESSION_HEADER_SCAN_BYTES}-byte scan limit: ${filePath}`);
+        this.name = "SessionHeaderScanLimitError";
+    }
+}
 function parseSessionEntryLine(line) {
     if (!line.trim())
         return null;
@@ -308,22 +317,70 @@ export function loadEntriesFromFile(filePath) {
     }
     return entries;
 }
+/**
+ * Inspect a physical line while searching for the first parsed session entry.
+ * Blank and malformed lines are skipped to match loadEntriesFromFile().
+ * Returns undefined to keep scanning, null for a parsed non-header entry, or the header.
+ */
+function parseSessionHeaderCandidate(line) {
+    if (!line.trim())
+        return undefined;
+    const entry = parseSessionEntryLine(line);
+    if (!entry)
+        return undefined;
+    if (entry.type !== "session" || typeof entry.id !== "string")
+        return null;
+    return entry;
+}
 function readSessionHeader(filePath) {
+    const fd = openSync(filePath, "r");
     try {
-        const fd = openSync(filePath, "r");
-        const buffer = Buffer.alloc(512);
-        const bytesRead = readSync(fd, buffer, 0, 512, 0);
-        closeSync(fd);
-        const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n")[0];
-        if (!firstLine)
-            return null;
-        const header = JSON.parse(firstLine);
-        if (header.type !== "session" || typeof header.id !== "string") {
-            return null;
+        const decoder = new StringDecoder("utf8");
+        const buffer = Buffer.allocUnsafe(SESSION_HEADER_READ_BUFFER_SIZE);
+        const lineChunks = [];
+        let scannedBytes = 0;
+        while (scannedBytes < MAX_SESSION_HEADER_SCAN_BYTES) {
+            const readLength = Math.min(buffer.length, MAX_SESSION_HEADER_SCAN_BYTES - scannedBytes);
+            const bytesRead = readSync(fd, buffer, 0, readLength, null);
+            if (bytesRead === 0) {
+                lineChunks.push(decoder.end());
+                return parseSessionHeaderCandidate(lineChunks.join("")) ?? null;
+            }
+            scannedBytes += bytesRead;
+            const chunk = decoder.write(buffer.subarray(0, bytesRead));
+            let lineStart = 0;
+            let newlineIndex = chunk.indexOf("\n", lineStart);
+            while (newlineIndex !== -1) {
+                lineChunks.push(chunk.slice(lineStart, newlineIndex));
+                const header = parseSessionHeaderCandidate(lineChunks.join(""));
+                if (header !== undefined)
+                    return header;
+                lineChunks.length = 0;
+                lineStart = newlineIndex + 1;
+                newlineIndex = chunk.indexOf("\n", lineStart);
+            }
+            lineChunks.push(chunk.slice(lineStart));
         }
-        return header;
+        // Probe for EOF so a final header without a newline is allowed when it ends
+        // exactly at the scan limit. Any additional byte exceeds the bounded scan.
+        const probe = Buffer.allocUnsafe(1);
+        if (readSync(fd, probe, 0, probe.length, null) === 0) {
+            lineChunks.push(decoder.end());
+            return parseSessionHeaderCandidate(lineChunks.join("")) ?? null;
+        }
+        throw new SessionHeaderScanLimitError(filePath);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function readSessionHeaderForDiscovery(filePath) {
+    try {
+        return readSessionHeader(filePath);
     }
     catch {
+        // Discovery is best-effort: unreadable or oversized files are not sessions,
+        // and one corrupt file must not prevent other sessions from being found.
         return null;
     }
 }
@@ -342,7 +399,7 @@ export function findMostRecentSession(sessionDir, cwd) {
         const files = readdirSync(resolvedSessionDir)
             .filter((f) => f.endsWith(".jsonl"))
             .map((f) => join(resolvedSessionDir, f))
-            .map((path) => ({ path, header: readSessionHeader(path) }))
+            .map((path) => ({ path, header: readSessionHeaderForDiscovery(path) }))
             .filter((file) => file.header !== null &&
             (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd)))
             .map(({ path }) => ({ path, mtime: statSync(path).mtime }))
@@ -350,6 +407,7 @@ export function findMostRecentSession(sessionDir, cwd) {
         return files[0]?.path || null;
     }
     catch {
+        // Directory access and stat races make recent-session discovery unavailable.
         return null;
     }
 }
@@ -535,7 +593,7 @@ export class SessionManager {
     labelsById = new Map();
     labelTimestampsById = new Map();
     leafId = null;
-    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions) {
+    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions, preloadedFileEntries) {
         this.cwd = resolvePath(cwd);
         this.sessionDir = normalizePath(sessionDir);
         this.persist = persist;
@@ -543,7 +601,7 @@ export class SessionManager {
             mkdirSync(this.sessionDir, { recursive: true });
         }
         if (sessionFile) {
-            this.setSessionFile(sessionFile);
+            this._setSessionFile(sessionFile, preloadedFileEntries);
         }
         else {
             this.newSession(newSessionOptions);
@@ -551,15 +609,18 @@ export class SessionManager {
     }
     /** Switch to a different session file (used for resume and branching) */
     setSessionFile(sessionFile) {
+        this._setSessionFile(sessionFile);
+    }
+    _setSessionFile(sessionFile, preloadedFileEntries) {
         this.sessionFile = resolvePath(sessionFile);
         if (existsSync(this.sessionFile)) {
-            this.fileEntries = loadEntriesFromFile(this.sessionFile);
+            this.fileEntries = preloadedFileEntries ?? loadEntriesFromFile(this.sessionFile);
             // If file was empty, initialize it with a valid session header. If it was
             // non-empty but did not parse as a pi session, fail without modifying it.
             if (this.fileEntries.length === 0) {
                 const explicitPath = this.sessionFile;
                 if (statSync(explicitPath).size > 0) {
-                    throw new Error(`Session file is not a valid sling session: ${explicitPath}`);
+                    throw new Error(`Session file is not a valid pi session: ${explicitPath}`);
                 }
                 this.newSession();
                 this.sessionFile = explicitPath;
@@ -739,7 +800,7 @@ export class SessionManager {
         return entry.id;
     }
     /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
-    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
+    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook, usage) {
         const entry = {
             type: "compaction",
             id: generateId(this.byId),
@@ -749,6 +810,7 @@ export class SessionManager {
             firstKeptEntryId,
             tokensBefore,
             details,
+            usage,
             fromHook,
         };
         this._appendEntry(entry);
@@ -988,7 +1050,7 @@ export class SessionManager {
      * Same as branch(), but also appends a branch_summary entry that captures
      * context from the abandoned conversation path.
      */
-    branchWithSummary(branchFromId, summary, details, fromHook) {
+    branchWithSummary(branchFromId, summary, details, fromHook, usage) {
         if (branchFromId !== null && !this.byId.has(branchFromId)) {
             throw new Error(`Entry ${branchFromId} not found`);
         }
@@ -1001,6 +1063,7 @@ export class SessionManager {
             fromId: branchFromId ?? "root",
             summary,
             details,
+            usage,
             fromHook,
         };
         this._appendEntry(entry);
@@ -1122,13 +1185,26 @@ export class SessionManager {
      */
     static open(path, sessionDir, cwdOverride) {
         const resolvedPath = resolvePath(path);
-        // Extract cwd from session header if possible, otherwise use process.cwd()
-        const entries = loadEntriesFromFile(resolvedPath);
-        const header = entries.find((e) => e.type === "session");
-        const cwd = cwdOverride ?? header?.cwd ?? process.cwd();
+        let header = null;
+        let preloadedFileEntries;
+        if (cwdOverride === undefined && existsSync(resolvedPath)) {
+            try {
+                header = readSessionHeader(resolvedPath);
+            }
+            catch (error) {
+                if (!(error instanceof SessionHeaderScanLimitError))
+                    throw error;
+                // The bounded scan is only a discovery optimization. A full load remains
+                // authoritative for legacy files with very large headers or prefixes.
+                preloadedFileEntries = loadEntriesFromFile(resolvedPath);
+                const firstEntry = preloadedFileEntries[0];
+                header = firstEntry?.type === "session" ? firstEntry : null;
+            }
+        }
+        const cwd = cwdOverride ?? (header ? getSessionHeaderCwd(header) : undefined) ?? process.cwd();
         // If no sessionDir provided, derive from file's parent directory
         const dir = sessionDir ? normalizePath(sessionDir) : resolve(resolvedPath, "..");
-        return new SessionManager(cwd, dir, resolvedPath, true);
+        return new SessionManager(cwd, dir, resolvedPath, true, undefined, preloadedFileEntries);
     }
     /**
      * Continue the most recent session, or create new if none.

package/node_modules/@earendil-works/pi-coding-agent/dist/core/usage-totals.js

@@ -0,0 +1,52 @@
+export function createUsageTotals() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: 0,
+    };
+}
+export function addUsageToTotals(totals, usage) {
+    totals.input += usage.input;
+    totals.output += usage.output;
+    totals.cacheRead += usage.cacheRead;
+    totals.cacheWrite += usage.cacheWrite;
+    totals.cost += usage.cost.total;
+}
+/** Group attributable assistant usage by model and all other usage into a separate bucket. */
+export function getUsageCostBreakdown(entries) {
+    const totalsByKey = new Map();
+    for (const entry of entries) {
+        let key;
+        let usage;
+        if (entry.type === "message" && entry.message.role === "assistant") {
+            key = `${entry.message.provider}/${entry.message.responseModel ?? entry.message.model}`;
+            usage = entry.message.usage;
+        }
+        else if (entry.type === "message" && entry.message.role === "toolResult" && entry.message.usage) {
+            key = "Tools/summaries";
+            usage = entry.message.usage;
+        }
+        else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+            key = "Tools/summaries";
+            usage = entry.usage;
+        }
+        if (!key || !usage)
+            continue;
+        let totals = totalsByKey.get(key);
+        if (!totals) {
+            totals = createUsageTotals();
+            totalsByKey.set(key, totals);
+        }
+        addUsageToTotals(totals, usage);
+    }
+    return Array.from(totalsByKey, ([key, totals]) => ({
+        key,
+        cost: totals.cost,
+        tokens: totals.input + totals.output + totals.cacheRead + totals.cacheWrite,
+    }))
+        .filter((entry) => entry.cost > 0 || entry.tokens > 0)
+        .sort((a, b) => b.cost - a.cost);
+}
+//# sourceMappingURL=usage-totals.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/extensions/llama/client.js

@@ -67,9 +67,11 @@ function parseLoadProgress(data) {
 function parseDownloadProgress(data) {
     if (typeof data !== "object" || data === null)
         return undefined;
+    const nested = data.progress;
+    const files = typeof nested === "object" && nested !== null ? nested : data;
     let done = 0;
     let total = 0;
-    for (const value of Object.values(data)) {
+    for (const value of Object.values(files)) {
         if (typeof value !== "object" || value === null)
             continue;
         const entry = value;

package/node_modules/@earendil-works/pi-coding-agent/dist/extensions/llama/index.js

@@ -70,7 +70,7 @@ export default function llamaExtension(pi) {
                 model: target.id,
                 initialMessage: "Starting…",
                 cancelTitle: "Stop loading?",
-                cancelMessage: `Stop loading ${target.id}?`,
+                cancelMessage: target.id,
                 run: (signal, update) => client.loadAndWait(target.id, update, signal),
                 cancel: () => client.unload(target.id),
             });
@@ -96,7 +96,7 @@ export default function llamaExtension(pi) {
         }
     };
     const unloadModel = async (ctx, ui, client, model) => {
-        if (!(await ui.confirm("Unload model?", `Unload ${model.id}?`)))
+        if (!(await ui.confirm("Unload model?", model.id)))
             return;
         await client.unloadAndWait(model.id);
         await syncCatalog(ctx, client);
@@ -140,7 +140,7 @@ export default function llamaExtension(pi) {
             model,
             initialMessage: "Starting…",
             cancelTitle: "Stop download?",
-            cancelMessage: `Stop downloading ${model}?`,
+            cancelMessage: model,
             run: (signal, update) => client.downloadAndWait(model, update, signal),
             cancel: () => client.unload(model),
         });

package/node_modules/@earendil-works/pi-coding-agent/dist/index.js

@@ -5,7 +5,7 @@ export { CONFIG_DIR_NAME, getAgentDir, getDocsPath, getExamplesPath, getPackageD
 export { AgentSession, parseSkillBlock, } from "./core/agent-session.js";
 export { readStoredCredential } from "./core/auth-storage.js";
 // Compaction
-export { calculateContextTokens, collectEntriesForBranchSummary, compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, findTurnStartIndex, generateBranchSummary, generateSummary, getLastAssistantUsage, prepareBranchEntries, serializeConversation, shouldCompact, } from "./core/compaction/index.js";
+export { calculateContextTokens, collectEntriesForBranchSummary, compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, findTurnStartIndex, generateBranchSummary, generateSummary, generateSummaryWithUsage, getLastAssistantUsage, prepareBranchEntries, serializeConversation, shouldCompact, } from "./core/compaction/index.js";
 export { createEventBus } from "./core/event-bus.js";
 export { createExtensionRuntime, defineTool, discoverAndLoadExtensions, ExtensionRunner, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, wrapRegisteredTool, wrapRegisteredTools, } from "./core/extensions/index.js";
 export { convertToLlm } from "./core/messages.js";

package/node_modules/@earendil-works/pi-coding-agent/dist/main.js

@@ -563,7 +563,7 @@ export async function main(args, options) {
                 });
             }
             else {
-                await modelRuntime.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+                await modelRuntime.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey, { allowNetwork: false });
                 await services.modelRuntime.getAvailable();
             }
         }
@@ -647,6 +647,10 @@ export async function main(args, options) {
         console.error(chalk.red("Error: PI_STARTUP_BENCHMARK only supports interactive mode"));
         process.exit(1);
     }
+    // RPC refreshes catalogs here in the background; interactive mode starts its refresh after TUI initialization.
+    if (!offlineMode && appMode === "rpc") {
+        void modelRuntime.refresh().catch(() => { });
+    }
     if (appMode === "rpc") {
         printTimings();
         await runRpcMode(runtime);

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/footer.js

@@ -1,6 +1,7 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { areExperimentalFeaturesEnabled } from "../../../core/experimental.js";
+import { addUsageToTotals, createUsageTotals } from "../../../core/usage-totals.js";
 import { theme } from "../theme/theme.js";
 /**
  * Sanitize text for display in a single-line status.
@@ -74,23 +75,21 @@ export class FooterComponent {
     render(width) {
         const state = this.session.state;
         // Calculate cumulative usage from ALL session entries (not just post-compaction messages)
-        let totalInput = 0;
-        let totalOutput = 0;
-        let totalCacheRead = 0;
-        let totalCacheWrite = 0;
-        let totalCost = 0;
+        const usageTotals = createUsageTotals();
         let latestCacheHitRate;
         for (const entry of this.session.sessionManager.getEntries()) {
             if (entry.type === "message" && entry.message.role === "assistant") {
-                totalInput += entry.message.usage.input;
-                totalOutput += entry.message.usage.output;
-                totalCacheRead += entry.message.usage.cacheRead;
-                totalCacheWrite += entry.message.usage.cacheWrite;
-                totalCost += entry.message.usage.cost.total;
+                addUsageToTotals(usageTotals, entry.message.usage);
                 const latestPromptTokens = entry.message.usage.input + entry.message.usage.cacheRead + entry.message.usage.cacheWrite;
                 latestCacheHitRate =
                     latestPromptTokens > 0 ? (entry.message.usage.cacheRead / latestPromptTokens) * 100 : undefined;
             }
+            else if (entry.type === "message" && entry.message.role === "toolResult" && entry.message.usage) {
+                addUsageToTotals(usageTotals, entry.message.usage);
+            }
+            else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+                addUsageToTotals(usageTotals, entry.usage);
+            }
         }
         // Calculate context usage from session (handles compaction correctly).
         // After compaction, tokens are unknown until the next LLM response.
@@ -112,23 +111,23 @@ export class FooterComponent {
         }
         // Build stats line
         const statsParts = [];
-        if (totalInput)
-            statsParts.push(`↑${formatTokens(totalInput)}`);
-        if (totalOutput)
-            statsParts.push(`↓${formatTokens(totalOutput)}`);
-        if (totalCacheRead)
-            statsParts.push(`R${formatTokens(totalCacheRead)}`);
-        if (totalCacheWrite)
-            statsParts.push(`W${formatTokens(totalCacheWrite)}`);
-        if ((totalCacheRead > 0 || totalCacheWrite > 0) && latestCacheHitRate !== undefined) {
+        if (usageTotals.input)
+            statsParts.push(`↑${formatTokens(usageTotals.input)}`);
+        if (usageTotals.output)
+            statsParts.push(`↓${formatTokens(usageTotals.output)}`);
+        if (usageTotals.cacheRead)
+            statsParts.push(`R${formatTokens(usageTotals.cacheRead)}`);
+        if (usageTotals.cacheWrite)
+            statsParts.push(`W${formatTokens(usageTotals.cacheWrite)}`);
+        if ((usageTotals.cacheRead > 0 || usageTotals.cacheWrite > 0) && latestCacheHitRate !== undefined) {
             statsParts.push(`CH${latestCacheHitRate.toFixed(1)}%`);
         }
         // Kimi Coding is subscription-backed despite using API-key authentication.
         const usingSubscription = state.model
             ? state.model.provider === "kimi-coding" || this.session.modelRuntime.isUsingOAuth(state.model.provider)
             : false;
-        if (totalCost || usingSubscription) {
-            const costStr = `$${totalCost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`;
+        if (usageTotals.cost || usingSubscription) {
+            const costStr = `$${usageTotals.cost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`;
             statsParts.push(costStr);
         }
         // Colorize context percentage based on usage