@psnext/slingcli 2.5.20260710-1 → 2.5.20260718-2

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

@@ -1,12 +1,7 @@
 /**
- * Credential storage for API keys and OAuth tokens.
- * Handles loading, saving, and refreshing credentials from auth.json.
- *
- * Uses file locking to prevent race conditions when multiple pi instances
- * try to refresh tokens simultaneously.
+ * CredentialStore implementation backed by auth.json.
+ * Provider auth orchestration belongs to ModelRuntime and pi-ai Models.
  */
-import { findEnvKeys, getEnvApiKey, } from "@earendil-works/pi-ai/compat";
-import { getOAuthApiKey, getOAuthProvider, getOAuthProviders } from "@earendil-works/pi-ai/oauth";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import lockfile from "proper-lockfile";
@@ -146,9 +141,6 @@ export class InMemoryAuthStorageBackend {
  */
 export class AuthStorage {
     data = {};
-    runtimeOverrides = new Map();
-    loadError = null;
-    errors = [];
     storage;
     constructor(storage) {
         this.storage = storage;
@@ -165,23 +157,6 @@ export class AuthStorage {
         storage.withLock(() => ({ result: undefined, next: JSON.stringify(data, null, 2) }));
         return AuthStorage.fromStorage(storage);
     }
-    /**
-     * Set a runtime API key override (not persisted to disk).
-     * Used for CLI --api-key flag.
-     */
-    setRuntimeApiKey(provider, apiKey) {
-        this.runtimeOverrides.set(provider, apiKey);
-    }
-    /**
-     * Remove a runtime API key override.
-     */
-    removeRuntimeApiKey(provider) {
-        this.runtimeOverrides.delete(provider);
-    }
-    recordError(error) {
-        const normalizedError = error instanceof Error ? error : new Error(String(error));
-        this.errors.push(normalizedError);
-    }
     parseStorageData(content) {
         if (!content) {
             return {};
@@ -199,244 +174,56 @@ export class AuthStorage {
                 return { result: undefined };
             });
             this.data = this.parseStorageData(content);
-            this.loadError = null;
-        }
-        catch (error) {
-            this.loadError = error;
-            this.recordError(error);
-        }
-    }
-    persistProviderChange(provider, credential) {
-        if (this.loadError) {
-            this.reload();
-        }
-        if (this.loadError) {
-            const error = new Error(`Cannot update auth storage because it could not be loaded: ${this.loadError.message}`);
-            this.recordError(error);
-            throw error;
-        }
-        try {
-            let persistedData = {};
-            this.storage.withLock((current) => {
-                const currentData = this.parseStorageData(current);
-                const merged = { ...currentData };
-                if (credential) {
-                    merged[provider] = credential;
-                }
-                else {
-                    delete merged[provider];
-                }
-                persistedData = merged;
-                return { result: undefined, next: JSON.stringify(merged, null, 2) };
-            });
-            this.loadError = null;
-            return persistedData;
-        }
-        catch (error) {
-            this.recordError(error);
-            throw error;
-        }
-    }
-    /**
-     * Get credential for a provider.
-     */
-    get(provider) {
-        return this.data[provider] ?? undefined;
-    }
-    /**
-     * Get provider-scoped environment values for an API key credential.
-     */
-    getProviderEnv(provider) {
-        const cred = this.data[provider];
-        return cred?.type === "api_key" && cred.env ? { ...cred.env } : undefined;
-    }
-    /**
-     * Set credential for a provider.
-     */
-    set(provider, credential) {
-        this.data = this.persistProviderChange(provider, credential);
-    }
-    /**
-     * Remove credential for a provider.
-     */
-    remove(provider) {
-        this.data = this.persistProviderChange(provider, undefined);
-    }
-    /**
-     * List all providers with credentials.
-     */
-    list() {
-        return Object.keys(this.data);
-    }
-    /**
-     * Check if credentials exist for a provider in auth.json.
-     */
-    has(provider) {
-        return provider in this.data;
-    }
-    /**
-     * Check if any form of auth is configured for a provider.
-     * Unlike getApiKey(), this doesn't refresh OAuth tokens.
-     */
-    hasAuth(provider) {
-        if (this.runtimeOverrides.has(provider))
-            return true;
-        if (this.data[provider])
-            return true;
-        if (getEnvApiKey(provider))
-            return true;
-        return false;
-    }
-    /**
-     * Return auth status without exposing credential values or refreshing tokens.
-     */
-    getAuthStatus(provider) {
-        if (this.data[provider]) {
-            return { configured: true, source: "stored" };
-        }
-        if (this.runtimeOverrides.has(provider)) {
-            return { configured: false, source: "runtime", label: "--api-key" };
         }
-        const envKeys = findEnvKeys(provider);
-        if (envKeys?.[0]) {
-            return { configured: false, source: "environment", label: envKeys[0] };
-        }
-        return { configured: false };
-    }
-    /**
-     * Get all credentials (for passing to getOAuthApiKey).
-     */
-    getAll() {
-        return { ...this.data };
-    }
-    drainErrors() {
-        const drained = [...this.errors];
-        this.errors = [];
-        return drained;
-    }
-    /**
-     * Login to an OAuth provider.
-     */
-    async login(providerId, callbacks) {
-        const provider = getOAuthProvider(providerId);
-        if (!provider) {
-            throw new Error(`Unknown OAuth provider: ${providerId}`);
-        }
-        const credentials = await provider.login(callbacks);
-        this.set(providerId, { type: "oauth", ...credentials });
-    }
-    /**
-     * Logout from a provider.
-     */
-    logout(provider) {
-        this.remove(provider);
-    }
-    /**
-     * Refresh OAuth token with backend locking to prevent race conditions.
-     * Multiple pi instances may try to refresh simultaneously when tokens expire.
-     */
-    async refreshOAuthTokenWithLock(providerId) {
-        const provider = getOAuthProvider(providerId);
-        if (!provider) {
-            return null;
-        }
-        const result = await this.storage.withLockAsync(async (current) => {
-            const currentData = this.parseStorageData(current);
-            this.data = currentData;
-            this.loadError = null;
-            const cred = currentData[providerId];
-            if (cred?.type !== "oauth") {
-                return { result: null };
+        catch {
+            // Preserve the last valid in-memory snapshot.
+        }
+    }
+    async read(provider) {
+        const credential = this.data[provider];
+        if (credential?.type !== "api_key")
+            return credential;
+        if (credential.key === undefined)
+            return credential;
+        return { ...credential, key: resolveConfigValue(credential.key, credential.env) };
+    }
+    async modify(provider, fn) {
+        return this.storage.withLockAsync(async (content) => {
+            const currentData = this.parseStorageData(content);
+            const next = await fn(currentData[provider]);
+            if (next === undefined) {
+                this.data = currentData;
+                return { result: currentData[provider] };
             }
-            if (Date.now() < cred.expires) {
-                return { result: { apiKey: provider.getApiKey(cred), newCredentials: cred } };
-            }
-            const oauthCreds = {};
-            for (const [key, value] of Object.entries(currentData)) {
-                if (value.type === "oauth") {
-                    oauthCreds[key] = value;
-                }
-            }
-            const refreshed = await getOAuthApiKey(providerId, oauthCreds);
-            if (!refreshed) {
-                return { result: null };
-            }
-            const merged = {
-                ...currentData,
-                [providerId]: { type: "oauth", ...refreshed.newCredentials },
-            };
+            const merged = { ...currentData, [provider]: next };
             this.data = merged;
-            this.loadError = null;
-            return { result: refreshed, next: JSON.stringify(merged, null, 2) };
+            return { result: next, next: JSON.stringify(merged, null, 2) };
         });
-        return result;
     }
-    /**
-     * Get API key for a provider.
-     * Priority:
-     * 1. Runtime override (CLI --api-key)
-     * 2. API key from auth.json
-     * 3. OAuth token from auth.json (auto-refreshed with locking)
-     * 4. Environment variable
-     */
-    async getApiKey(providerId, options = {}) {
-        // Runtime override takes highest priority
-        const runtimeKey = this.runtimeOverrides.get(providerId);
-        if (runtimeKey) {
-            return runtimeKey;
-        }
-        const cred = this.data[providerId];
-        if (cred?.type === "api_key") {
-            return resolveConfigValue(cred.key, cred.env);
-        }
-        if (cred?.type === "oauth") {
-            const provider = getOAuthProvider(providerId);
-            if (!provider) {
-                // Unknown OAuth provider, can't get API key
-                return undefined;
-            }
-            // Check if token needs refresh
-            const needsRefresh = Date.now() >= cred.expires;
-            if (needsRefresh) {
-                // Use locked refresh to prevent race conditions
-                try {
-                    const result = await this.refreshOAuthTokenWithLock(providerId);
-                    if (result) {
-                        return result.apiKey;
-                    }
-                }
-                catch (error) {
-                    this.recordError(error);
-                    // Refresh failed - re-read file to check if another instance succeeded
-                    this.reload();
-                    const updatedCred = this.data[providerId];
-                    if (updatedCred?.type === "oauth" && Date.now() < updatedCred.expires) {
-                        // Another instance refreshed successfully, use those credentials
-                        return provider.getApiKey(updatedCred);
-                    }
-                    // Refresh truly failed - return undefined so model discovery skips this provider
-                    // User can /login to re-authenticate (credentials preserved for retry)
-                    return undefined;
-                }
-            }
-            else {
-                // Token not expired, use current access token
-                return provider.getApiKey(cred);
-            }
-        }
-        if (options.includeFallback === false)
-            return undefined;
-        // Fall back to environment variable
-        const envKey = getEnvApiKey(providerId);
-        if (envKey)
-            return envKey;
-        return undefined;
+    async delete(provider) {
+        await this.storage.withLockAsync(async (content) => {
+            const currentData = this.parseStorageData(content);
+            delete currentData[provider];
+            this.data = currentData;
+            return { result: undefined, next: JSON.stringify(currentData, null, 2) };
+        });
     }
-    /**
-     * Get all registered OAuth providers
-     */
-    getOAuthProviders() {
-        return getOAuthProviders();
+    /** List credential metadata without resolving configured key values. */
+    async list() {
+        return Object.entries(this.data).map(([providerId, credential]) => ({ providerId, type: credential.type }));
+    }
+}
+/**
+ * One-off synchronous read of a stored credential from an auth.json file,
+ * without instantiating a store or resolving configured key values.
+ */
+export function readStoredCredential(providerId, authPath = join(getAgentDir(), "auth.json")) {
+    try {
+        const data = JSON.parse(readFileSync(normalizePath(authPath), "utf-8"));
+        return data[providerId];
+    }
+    catch {
+        return undefined;
     }
 }
 //# sourceMappingURL=auth-storage.js.map

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

@@ -0,0 +1,101 @@
+/**
+ * Prompt-cache TTL: idle gaps longer than this are worth mentioning as the
+ * likely cause of a miss. Anthropic's default cache TTL is 5 minutes.
+ */
+export const CACHE_TTL_MS = 5 * 60 * 1000;
+/** Per-turn misses at or below this are cache breakpoint granularity noise. */
+const NOISE_FLOOR_TOKENS = 1024;
+/**
+ * Compute the cache miss for one assistant message relative to the previous
+ * request. Returns undefined when nothing is counted: first turn, after a
+ * reset, no cache activity ever reported (provider without cache support), or
+ * miss below the noise floor.
+ */
+function detectMiss(prev, message, models) {
+    const usage = message.usage;
+    const promptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+    // A zero-cache turn only counts when cache activity was reported before:
+    // on cache-read-only providers that is a total miss, while on providers
+    // that never report caching it means nothing.
+    if (!prev || promptTokens <= 0 || (usage.cacheRead + usage.cacheWrite === 0 && !prev.reportedCache)) {
+        return undefined;
+    }
+    const missedTokens = Math.min(prev.promptTokens, promptTokens) - usage.cacheRead;
+    if (missedTokens <= NOISE_FLOOR_TOKENS)
+        return undefined;
+    // Extra cost = missed tokens billed at the actual paid rate (input/cacheWrite,
+    // incl. write premium) instead of the cache-read rate. Missed tokens can only
+    // land in the input or cacheWrite buckets, so the paid rate comes straight
+    // from this message's own cost breakdown.
+    const paidTokens = usage.input + usage.cacheWrite;
+    const paidPerToken = paidTokens > 0 ? (usage.cost.input + usage.cost.cacheWrite) / paidTokens : 0;
+    const readPerToken = usage.cacheRead > 0
+        ? usage.cost.cacheRead / usage.cacheRead
+        : (models.getModel(message.provider, message.model)?.cost.cacheRead ?? 0) / 1_000_000;
+    return {
+        missedTokens,
+        missedCost: missedTokens * Math.max(0, paidPerToken - readPerToken),
+        idleMs: Math.max(0, message.timestamp - prev.timestamp),
+        modelChanged: `${message.provider}/${message.model}` !== prev.modelKey,
+    };
+}
+function asPreviousRequest(message, reportedCache) {
+    const usage = message.usage;
+    const promptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+    if (promptTokens <= 0)
+        return undefined;
+    return {
+        promptTokens,
+        modelKey: `${message.provider}/${message.model}`,
+        timestamp: message.timestamp,
+        reportedCache: reportedCache || usage.cacheRead + usage.cacheWrite > 0,
+    };
+}
+function scan(entries, models) {
+    let prev;
+    const totals = { missedTokens: 0, missedCost: 0, missCount: 0 };
+    const misses = new Map();
+    for (const entry of entries) {
+        if (entry.type === "compaction" || entry.type === "branch_summary") {
+            // The context legitimately changed; the next turn's prompt is new content,
+            // not re-billed content. Model switches are NOT exempt: they re-bill the
+            // full prompt and should be counted.
+            prev = undefined;
+            continue;
+        }
+        if (entry.type === "message" && entry.message.role === "assistant") {
+            const miss = detectMiss(prev, entry.message, models);
+            if (miss) {
+                totals.missedTokens += miss.missedTokens;
+                totals.missedCost += miss.missedCost;
+                totals.missCount += 1;
+                misses.set(entry.message, miss);
+            }
+            prev = asPreviousRequest(entry.message, prev?.reportedCache ?? false) ?? prev;
+        }
+    }
+    return { prev, totals, misses };
+}
+/**
+ * Cumulative cache waste across a session: prompt tokens that should have been
+ * cache reads (they were in the previous turn's prompt) but were re-billed.
+ */
+export function computeCacheWaste(entries, models) {
+    return scan(entries, models).totals;
+}
+/**
+ * All counted cache misses across a session, keyed by the assistant message
+ * (by reference) that paid for them. Used to re-derive transcript notices when
+ * rebuilding the chat from entries (resume, post-compaction rebuild).
+ */
+export function collectCacheMisses(entries, models) {
+    return scan(entries, models).misses;
+}
+/**
+ * Detect a cache miss on a just-completed assistant message.
+ * `entries` must not yet contain `message` (message_end fires before persistence).
+ */
+export function detectCacheMiss(entries, message, models) {
+    return detectMiss(scan(entries, models).prev, message, models);
+}
+//# sourceMappingURL=cache-stats.js.map

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

@@ -5,8 +5,8 @@
  * and after compaction the session is reloaded.
  */
 import { completeSimple } from "@earendil-works/pi-ai/compat";
-import { convertToLlm, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
-import { buildSessionContext } from "../session-manager.js";
+import { convertToLlm } from "../messages.js";
+import { buildSessionContext, sessionEntryToContextMessages, } from "../session-manager.js";
 import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, SUMMARIZATION_SYSTEM_PROMPT, serializeConversation, } from "./utils.js";
 /**
  * Extract file operations from messages and previous compaction entries.
@@ -42,26 +42,11 @@ function extractFileOperations(messages, entries, prevCompactionIndex) {
  * Extract AgentMessage from an entry if it produces one.
  * Returns undefined for entries that don't contribute to LLM context.
  */
-function getMessageFromEntry(entry) {
-    if (entry.type === "message") {
-        return entry.message;
-    }
-    if (entry.type === "custom_message") {
-        return createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp);
-    }
-    if (entry.type === "branch_summary") {
-        return createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp);
-    }
-    if (entry.type === "compaction") {
-        return createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp);
-    }
-    return undefined;
-}
 function getMessageFromEntryForCompaction(entry) {
     if (entry.type === "compaction") {
         return undefined;
     }
-    return getMessageFromEntry(entry);
+    return sessionEntryToContextMessages(entry)[0];
 }
 export const DEFAULT_COMPACTION_SETTINGS = {
     enabled: true,
@@ -216,69 +201,68 @@ export function estimateTokens(message) {
     }
     return 0;
 }
+function isCutPointMessage(message) {
+    switch (message.role) {
+        case "user":
+        case "assistant":
+        case "bashExecution":
+        case "custom":
+        case "branchSummary":
+        case "compactionSummary":
+            return true;
+        case "toolResult":
+            return false;
+    }
+    return false;
+}
+function isTurnStartMessage(message) {
+    switch (message.role) {
+        case "user":
+        case "bashExecution":
+        case "custom":
+        case "branchSummary":
+        case "compactionSummary":
+            return true;
+        case "assistant":
+        case "toolResult":
+            return false;
+    }
+    return false;
+}
+function isTurnStartEntry(entry) {
+    if (entry.type === "compaction") {
+        return false;
+    }
+    return sessionEntryToContextMessages(entry).some(isTurnStartMessage);
+}
 /**
- * Find valid cut points: indices of user, assistant, custom, or bashExecution messages.
+ * Find valid cut points: indices of context-visible user-like or assistant messages.
  * Never cut at tool results (they must follow their tool call).
  * When we cut at an assistant message with tool calls, its tool results follow it
  * and will be kept.
- * BashExecutionMessage is treated like a user message (user-initiated context).
  */
 function findValidCutPoints(entries, startIndex, endIndex) {
     const cutPoints = [];
     for (let i = startIndex; i < endIndex; i++) {
         const entry = entries[i];
-        switch (entry.type) {
-            case "message": {
-                const role = entry.message.role;
-                switch (role) {
-                    case "bashExecution":
-                    case "custom":
-                    case "branchSummary":
-                    case "compactionSummary":
-                    case "user":
-                    case "assistant":
-                        cutPoints.push(i);
-                        break;
-                    case "toolResult":
-                        break;
-                }
-                break;
-            }
-            case "thinking_level_change":
-            case "model_change":
-            case "compaction":
-            case "branch_summary":
-            case "custom":
-            case "custom_message":
-            case "label":
-            case "session_info":
-                break;
+        if (entry.type === "compaction") {
+            continue;
         }
-        // branch_summary and custom_message are user-role messages, valid cut points
-        if (entry.type === "branch_summary" || entry.type === "custom_message") {
+        if (sessionEntryToContextMessages(entry).some(isCutPointMessage)) {
             cutPoints.push(i);
         }
     }
     return cutPoints;
 }
 /**
- * Find the user message (or bashExecution) that starts the turn containing the given entry index.
+ * Find the context-visible user-role message that starts the turn containing the given entry index.
  * Returns -1 if no turn start found before the index.
- * BashExecutionMessage is treated like a user message for turn boundaries.
  */
 export function findTurnStartIndex(entries, entryIndex, startIndex) {
     for (let i = entryIndex; i >= startIndex; i--) {
-        const entry = entries[i];
-        // branch_summary and custom_message are user-role messages, can start a turn
-        if (entry.type === "branch_summary" || entry.type === "custom_message") {
+        if (isTurnStartEntry(entries[i])) {
             return i;
         }
-        if (entry.type === "message") {
-            const role = entry.message.role;
-            if (role === "user" || role === "bashExecution") {
-                return i;
-            }
-        }
     }
     return -1;
 }
@@ -308,10 +292,9 @@ export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
     let cutIndex = cutPoints[0]; // Default: keep from first message (not header)
     for (let i = endIndex - 1; i >= startIndex; i--) {
         const entry = entries[i];
-        if (entry.type !== "message")
+        const messageTokens = sessionEntryToContextMessages(entry).reduce((sum, message) => sum + estimateTokens(message), 0);
+        if (messageTokens === 0)
             continue;
-        // Estimate this message's size
-        const messageTokens = estimateTokens(entry.message);
         accumulatedTokens += messageTokens;
         // Check if we've exceeded the budget
         if (accumulatedTokens >= keepRecentTokens) {
@@ -325,28 +308,23 @@ export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
             break;
         }
     }
-    // Scan backwards from cutIndex to include any non-message entries (bash, settings, etc.)
+    // Scan backwards from cutIndex to include adjacent metadata entries that do not affect context.
     while (cutIndex > startIndex) {
         const prevEntry = entries[cutIndex - 1];
-        // Stop at session header or compaction boundaries
-        if (prevEntry.type === "compaction") {
-            break;
-        }
-        if (prevEntry.type === "message") {
-            // Stop if we hit any message
+        // Stop at compaction boundaries or context-visible entries.
+        if (prevEntry.type === "compaction" || sessionEntryToContextMessages(prevEntry).length > 0) {
             break;
         }
-        // Include this non-message entry (bash, settings change, etc.)
         cutIndex--;
     }
     // Determine if this is a split turn
     const cutEntry = entries[cutIndex];
-    const isUserMessage = cutEntry.type === "message" && cutEntry.message.role === "user";
-    const turnStartIndex = isUserMessage ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
+    const startsTurn = isTurnStartEntry(cutEntry);
+    const turnStartIndex = startsTurn ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
     return {
         firstKeptEntryIndex: cutIndex,
         turnStartIndex,
-        isSplitTurn: !isUserMessage && turnStartIndex !== -1,
+        isSplitTurn: !startsTurn && turnStartIndex !== -1,
     };
 }
 // ============================================================================