@prestyj/cli 5.28.1 → 5.29.1

package/dist/core/cache-expiry.d.ts

@@ -0,0 +1,87 @@
+import type { CacheRetention } from "@prestyj/ai";
+/**
+ * Cold-prompt-cache detection (mirrors langchain-ai/deepagents#6477's
+ * `cold_cache.py`): providers keep the conversation prefix cached only for a
+ * TTL, so after a break the next message re-reads the whole context uncached.
+ *
+ * Every TTL below is derived from what @prestyj/ai actually puts on the wire — never
+ * from a provider's marketing maximum we did not request. A provider/route we
+ * cannot pin to a request-side TTL returns `null` (no warning) rather than a
+ * guess.
+ */
+export interface CacheTtlPolicy {
+    ttlMs: number;
+    /**
+     * `expired`: the TTL is a documented/requested *maximum* — past it the entry
+     * is gone. `may_be_cold`: the TTL is a guaranteed *minimum* (GPT-5.6+ `30m`),
+     * so past it the prefix may still be warm.
+     */
+    confidence: "expired" | "may_be_cold";
+    /** Where the number comes from, for logs/diagnostics. */
+    source: string;
+}
+export interface CacheTtlInput {
+    provider: string;
+    model: string;
+    cacheRetention: CacheRetention;
+    baseUrl?: string;
+    /** OpenAI OAuth (ChatGPT/Codex) routes carry an account id. */
+    accountId?: string;
+}
+/** Resolve the cache TTL our provider code requests for this route. */
+export declare function resolveCacheTtl(input: CacheTtlInput): CacheTtlPolicy | null;
+/**
+ * Prefix size below which the notice is not worth an interruption. At 40k
+ * tokens a cold Anthropic re-read (1.25x write vs 0.1x cached read) costs ~12x
+ * the warm request, roughly a dime on Sonnet-class pricing; below that the delta
+ * is pennies — and compacting first itself re-reads the whole context once, so
+ * on small chats "Compact first" saves nothing.
+ */
+export declare const CACHE_EXPIRY_NOTICE_MIN_TOKENS = 40000;
+export interface CacheTouch {
+    at: number;
+    provider: string;
+    model: string;
+    policy: CacheTtlPolicy;
+}
+export interface CacheExpiryStatus {
+    /** Owning session, so clients can key "dismissed once per expiry per chat". */
+    sessionId?: string;
+    provider: string;
+    ttlMs: number;
+    confidence: CacheTtlPolicy["confidence"];
+    ttlSource: string;
+    /** Last successful cache-using request (real turn or prewarm), epoch ms. */
+    lastRequestAt: number | null;
+    /** When the cached prefix lapses/lapsed, epoch ms; null when age is unknown. */
+    expiresAt: number | null;
+    expired: boolean;
+    /**
+     * `idle`: TTL passed. `age_unknown`: resumed/reset session with no request in
+     * this process. `identity_changed`: provider/model switched since the last
+     * request, so the old prefix cannot be reused.
+     */
+    reason: "idle" | "age_unknown" | "identity_changed" | null;
+    /** Tokens the next request would re-read (the current context). */
+    prefixTokens: number;
+    minTokens: number;
+    /** expired AND prefixTokens >= minTokens: worth showing the notice. */
+    notable: boolean;
+    /** No authoritative pricing exists in GG (turn metric cost is "unavailable"). */
+    estimatedExtraCostUsd: null;
+}
+export interface AssessCacheExpiryInput {
+    /** Policy for the route the NEXT request will take. */
+    current: {
+        provider: string;
+        model: string;
+        policy: CacheTtlPolicy | null;
+    };
+    lastTouch: CacheTouch | null;
+    now: number;
+    prefixTokens: number;
+    /** False for an empty chat — nothing to re-read. */
+    hasHistory: boolean;
+    minTokens?: number;
+}
+export declare function assessCacheExpiry(input: AssessCacheExpiryInput): CacheExpiryStatus | null;

package/dist/core/cache-expiry.js

@@ -0,0 +1,111 @@
+const MINUTE = 60_000;
+/** Resolve the cache TTL our provider code requests for this route. */
+export function resolveCacheTtl(input) {
+    if (input.cacheRetention === "none")
+        return null;
+    if (input.provider === "anthropic") {
+        // @prestyj/ai/src/providers/transform.ts `toAnthropicCacheControl`: "long" sends
+        // `ttl: "1h"` only on the first-party endpoint; everything else sends a bare
+        // `{type: "ephemeral"}`, which is Anthropic's 5-minute default.
+        const firstParty = !input.baseUrl || input.baseUrl.includes("api.anthropic.com");
+        if (input.cacheRetention === "long" && firstParty) {
+            return {
+                ttlMs: 60 * MINUTE,
+                confidence: "expired",
+                source: "anthropic cache_control ttl=1h (transform.ts toAnthropicCacheControl)",
+            };
+        }
+        return {
+            ttlMs: 5 * MINUTE,
+            confidence: "expired",
+            source: "anthropic cache_control ephemeral default 5m (transform.ts toAnthropicCacheControl)",
+        };
+    }
+    if (input.provider === "openai") {
+        if (input.accountId) {
+            // @prestyj/ai/src/providers/openai-codex.ts: the Codex backend rejects
+            // prompt_cache_retention; "Cache TTL on Codex is controlled server-side
+            // (~5-10 min in-memory)". Use the upper bound so we only warn once the
+            // entry is surely gone.
+            return {
+                ttlMs: 10 * MINUTE,
+                confidence: "expired",
+                source: "codex server-side in-memory cache ~5-10m (openai-codex.ts)",
+            };
+        }
+        if (input.model.startsWith("gpt-5.6") || input.model.startsWith("gpt-6")) {
+            // @prestyj/ai/src/providers/openai.ts sends prompt_cache_options.ttl = "30m";
+            // OpenAI documents 30 minutes as a guaranteed minimum.
+            return {
+                ttlMs: 30 * MINUTE,
+                confidence: "may_be_cold",
+                source: "openai prompt_cache_options ttl=30m (openai.ts)",
+            };
+        }
+        if (input.cacheRetention === "long") {
+            // @prestyj/ai/src/providers/openai.ts sends prompt_cache_retention = "24h".
+            return {
+                ttlMs: 24 * 60 * MINUTE,
+                confidence: "expired",
+                source: "openai prompt_cache_retention=24h (openai.ts)",
+            };
+        }
+        // No retention param sent → OpenAI's default in-memory retention, which
+        // its prompt-caching guide documents as up to one hour (a maximum).
+        return {
+            ttlMs: 60 * MINUTE,
+            confidence: "expired",
+            source: "openai default in_memory retention, max 1h (no param sent by openai.ts)",
+        };
+    }
+    // Other providers (Gemini, GLM, Moonshot, OpenRouter, local, …): we request
+    // no TTL and have no documented window to anchor a warning on.
+    return null;
+}
+/**
+ * Prefix size below which the notice is not worth an interruption. At 40k
+ * tokens a cold Anthropic re-read (1.25x write vs 0.1x cached read) costs ~12x
+ * the warm request, roughly a dime on Sonnet-class pricing; below that the delta
+ * is pennies — and compacting first itself re-reads the whole context once, so
+ * on small chats "Compact first" saves nothing.
+ */
+export const CACHE_EXPIRY_NOTICE_MIN_TOKENS = 40_000;
+export function assessCacheExpiry(input) {
+    const { current, lastTouch, now } = input;
+    if (!input.hasHistory || !current.policy)
+        return null;
+    const minTokens = input.minTokens ?? CACHE_EXPIRY_NOTICE_MIN_TOKENS;
+    const prefixTokens = Math.max(0, Math.round(input.prefixTokens));
+    let reason = null;
+    let expiresAt = null;
+    // The entry lives by the TTL it was WRITTEN with, not the current setting.
+    let policy = current.policy;
+    if (!lastTouch) {
+        reason = "age_unknown";
+    }
+    else if (lastTouch.provider !== current.provider || lastTouch.model !== current.model) {
+        reason = "identity_changed";
+    }
+    else {
+        policy = lastTouch.policy;
+        expiresAt = lastTouch.at + policy.ttlMs;
+        if (now >= expiresAt)
+            reason = "idle";
+    }
+    const expired = reason !== null;
+    return {
+        provider: current.provider,
+        ttlMs: policy.ttlMs,
+        confidence: policy.confidence,
+        ttlSource: policy.source,
+        lastRequestAt: lastTouch?.at ?? null,
+        expiresAt,
+        expired,
+        reason,
+        prefixTokens,
+        minTokens,
+        notable: expired && prefixTokens >= minTokens,
+        estimatedExtraCostUsd: null,
+    };
+}
+//# sourceMappingURL=cache-expiry.js.map

package/dist/core/cache-expiry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-expiry.js","sourceRoot":"","sources":["../../src/core/cache-expiry.ts"],"names":[],"mappings":"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"}

package/dist/core/codex-request-shape.d.ts

@@ -0,0 +1,12 @@
+/** User setting for an OpenAI request-shape option: `auto` (fast) or forced on/off. */
+export type CodexShapeSetting = "auto" | "on" | "off";
+/**
+ * The `responsesLite` stream option for this route, or undefined where the
+ * model never uses lite (the provider ignores it there).
+ */
+export declare function resolveResponsesLite(setting: CodexShapeSetting, provider: string, model: string): boolean | undefined;
+/**
+ * The `strictTools` stream option for this route, or undefined off OpenAI
+ * (other providers never send strict schemas).
+ */
+export declare function resolveStrictTools(setting: CodexShapeSetting, provider: string): boolean | undefined;

package/dist/core/codex-request-shape.js

@@ -0,0 +1,31 @@
+import { usesResponsesLite } from "@prestyj/ai";
+/**
+ * `auto` picks the fast shape on every OpenAI model: no Responses-Lite and no
+ * strict tool schemas (measured in a head-to-head against the pi agent).
+ * - Lite caps a response at one tool call. Without it, gpt-6-astra,
+ *   gpt-6.1-sol and gpt-6-luna each put 3 independent reads in one response
+ *   instead of 1, and the Astra h2h suite finished 8% faster, no lost passes.
+ * - Strict schemas make every call carry each optional field as null; without
+ *   them requests finished ~0.6–1s sooner on all three models.
+ * `on` restores the previous (Codex CLI) behaviour.
+ */
+function resolve(setting, applies) {
+    if (!applies)
+        return undefined;
+    return setting === "on";
+}
+/**
+ * The `responsesLite` stream option for this route, or undefined where the
+ * model never uses lite (the provider ignores it there).
+ */
+export function resolveResponsesLite(setting, provider, model) {
+    return resolve(setting, provider === "openai" && usesResponsesLite(model));
+}
+/**
+ * The `strictTools` stream option for this route, or undefined off OpenAI
+ * (other providers never send strict schemas).
+ */
+export function resolveStrictTools(setting, provider) {
+    return resolve(setting, provider === "openai");
+}
+//# sourceMappingURL=codex-request-shape.js.map

package/dist/core/codex-request-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-request-shape.js","sourceRoot":"","sources":["../../src/core/codex-request-shape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAKhD;;;;;;;;;GASG;AACH,SAAS,OAAO,CAAC,OAA0B,EAAE,OAAgB;IAC3D,IAAI,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IAC/B,OAAO,OAAO,KAAK,IAAI,CAAC;AAC1B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAA0B,EAC1B,QAAgB,EAChB,KAAa;IAEb,OAAO,OAAO,CAAC,OAAO,EAAE,QAAQ,KAAK,QAAQ,IAAI,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAA0B,EAC1B,QAAgB;IAEhB,OAAO,OAAO,CAAC,OAAO,EAAE,QAAQ,KAAK,QAAQ,CAAC,CAAC;AACjD,CAAC"}

package/dist/core/compaction/compactor.js

@@ -1,9 +1,11 @@
 import { stream, } from "@prestyj/ai";
 import { estimateConversationTokens, estimateMessageTokens } from "./token-estimator.js";
 import { findLatestHumanQuery, selectQueryAwareContext } from "./query-aware-selector.js";
-import { getSummaryModel, getContextWindow } from "../model-registry.js";
+import { getSummaryModel, getContextWindow, getModel } from "../model-registry.js";
+import { isModelUnavailableFailure } from "../model-unavailable.js";
 import { kimiCodingHeaders, isKimiCodingEndpoint } from "../oauth/kimi.js";
 import { log } from "../logger.js";
+import { editTargetPaths } from "../../tools/edit-targets.js";
 /**
  * Per-message-part char caps when preparing messages for the summarizer.
  * Verbose tool output is capped aggressively; user messages are the highest-
@@ -332,6 +334,11 @@ export function extractFileOperations(messages) {
             if (!("type" in part) || part.type !== "tool_call")
                 continue;
             const tc = part;
+            if (tc.name === "edit") {
+                for (const target of editTargetPaths(tc.args))
+                    modified.add(target);
+                continue;
+            }
             const filePath = tc.args.file_path ?? tc.args.path ?? tc.args.file;
             if (typeof filePath !== "string")
                 continue;
@@ -955,13 +962,10 @@ export async function compact(messages, options) {
     // after generation, so every message that could be removed must be represented.
     const summarizationSource = messages.slice(1);
     const fileOps = extractFileOperations(summarizationSource);
-    // Pick the appropriate model for summarization
+    // The cheaper summary model goes first (see getSummaryModel). The ACTIVE
+    // model is the fallback when the provider rejects it — retired upstream, or
+    // not on the user's plan — which the registry cannot know in advance.
     const summaryModel = getSummaryModel(options.provider, options.model);
-    const summaryContextWindow = getContextWindow(summaryModel.id, {
-        provider: options.provider,
-        accountId: options.accountId,
-    });
-    const summaryOutputTokens = Math.min(summaryModel.maxOutputTokens, resolveSummaryOutputTokens(summaryContextWindow));
     const previousSummary = findLatestPreviousSummary(summarizationSource);
     // Carry the prior tracked edits forward as DATA, not as prose the summarizer
     // has to re-transcribe. Their originating tool calls were collapsed by an
@@ -981,10 +985,8 @@ export async function compact(messages, options) {
         ...extractFailingTests(summarizationSource),
     ], carriedTests.omitted);
     const classifiedMessages = classifyMessagesForSummary(summarizationSource);
-    // Budget: summary model context - output tokens - system/user prompt overhead (~1K).
     // Prior compacted memory is pinned separately, never presented as a fresh human turn.
     const promptOverhead = 1000;
-    const tokenBudget = summaryContextWindow - summaryOutputTokens - promptOverhead;
     const previousSummaryMessage = previousSummary
         ? {
             role: "user",
@@ -995,27 +997,6 @@ export async function compact(messages, options) {
         ? estimateMessageTokens(previousSummaryMessage)
         : 0;
     const query = findLatestHumanQuery(summarizationSource);
-    const contextSelection = selectQueryAwareContext(classifiedMessages, query, Math.max(0, tokenBudget - previousSummaryTokens), { fallback: selectMessagesInBudget });
-    const selectedMessages = contextSelection.messages;
-    log("INFO", "compaction", `Summarizing ${middleMessages.length} messages`, {
-        summaryModel: summaryModel.id,
-        summaryContextWindow: String(summaryContextWindow),
-        tokenBudget: String(tokenBudget),
-        preparedMessages: String(classifiedMessages.length),
-        selectedMessages: String(selectedMessages.length + (previousSummaryMessage ? 1 : 0)),
-        droppedMessages: String(contextSelection.droppedMessages),
-        selectedTokens: String(contextSelection.selectedTokens),
-        selectionStrategy: contextSelection.strategy,
-        queryTerms: String(contextSelection.queryTerms),
-        ...(contextSelection.fallbackReason
-            ? { selectionFallback: contextSelection.fallbackReason }
-            : {}),
-        previousSummary: String(!!previousSummaryMessage),
-        summaryOutputTokens: String(summaryOutputTokens),
-        filesModified: String(fileOps.modified.size),
-        filesModifiedCarried: String(carriedSummary.files.length),
-        recentKept: String(recentMessages.length),
-    });
     // Add plan preservation and summary-update instructions when applicable.
     const planPreservation = options.approvedPlanPath
         ? `\n\n### APPROVED PLAN PRESERVATION\n` +
@@ -1039,21 +1020,59 @@ export async function compact(messages, options) {
             "evidence completed, reversed, or made irrelevant. Never concatenate, never emit an 'update since " +
             "the previous summary' section, and never restate a fact in both old and new wording."
         : "";
-    const summaryMessages = [
-        {
-            role: "system",
-            content: COMPACTION_SYSTEM_PROMPT + planPreservation + focusDirective + updateInstruction,
-        },
-        ...(previousSummaryMessage ? [previousSummaryMessage] : []),
-        ...selectedMessages,
-        { role: "user", content: COMPACTION_USER_PROMPT },
-    ];
-    log("INFO", "compaction", `Calling summary LLM`, {
-        provider: options.provider,
-        model: summaryModel.id,
-        messageCount: String(summaryMessages.length),
-        hasApiKey: String(!!options.apiKey),
-    });
+    /**
+     * Size and assemble the summary request for one model. Re-run when the
+     * request moves to the active model, whose context window may be smaller.
+     */
+    const prepareSummaryRequest = (modelId) => {
+        const contextWindow = getContextWindow(modelId, {
+            provider: options.provider,
+            accountId: options.accountId,
+        });
+        const outputTokens = Math.min(getModel(modelId)?.maxOutputTokens ?? Number.POSITIVE_INFINITY, resolveSummaryOutputTokens(contextWindow));
+        // Budget: summary model context - output tokens - system/user prompt overhead (~1K).
+        const tokenBudget = contextWindow - outputTokens - promptOverhead;
+        const contextSelection = selectQueryAwareContext(classifiedMessages, query, Math.max(0, tokenBudget - previousSummaryTokens), { fallback: selectMessagesInBudget });
+        const selectedMessages = contextSelection.messages;
+        log("INFO", "compaction", `Summarizing ${middleMessages.length} messages`, {
+            summaryModel: modelId,
+            summaryContextWindow: String(contextWindow),
+            tokenBudget: String(tokenBudget),
+            preparedMessages: String(classifiedMessages.length),
+            selectedMessages: String(selectedMessages.length + (previousSummaryMessage ? 1 : 0)),
+            droppedMessages: String(contextSelection.droppedMessages),
+            selectedTokens: String(contextSelection.selectedTokens),
+            selectionStrategy: contextSelection.strategy,
+            queryTerms: String(contextSelection.queryTerms),
+            ...(contextSelection.fallbackReason
+                ? { selectionFallback: contextSelection.fallbackReason }
+                : {}),
+            previousSummary: String(!!previousSummaryMessage),
+            summaryOutputTokens: String(outputTokens),
+            filesModified: String(fileOps.modified.size),
+            filesModifiedCarried: String(carriedSummary.files.length),
+            recentKept: String(recentMessages.length),
+        });
+        const summaryMessages = [
+            {
+                role: "system",
+                content: COMPACTION_SYSTEM_PROMPT + planPreservation + focusDirective + updateInstruction,
+            },
+            ...(previousSummaryMessage ? [previousSummaryMessage] : []),
+            ...selectedMessages,
+            { role: "user", content: COMPACTION_USER_PROMPT },
+        ];
+        log("INFO", "compaction", `Calling summary LLM`, {
+            provider: options.provider,
+            model: modelId,
+            messageCount: String(summaryMessages.length),
+            hasApiKey: String(!!options.apiKey),
+        });
+        return { modelId, outputTokens, contextSelection, selectedMessages, summaryMessages };
+    };
+    let request = prepareSummaryRequest(summaryModel.id);
+    // Only a DIFFERENT model can rescue a rejected one.
+    let canFallBackToActiveModel = summaryModel.id !== options.model;
     // Retry empty successful responses only. Transport failures and timeouts use
     // the deterministic fallback immediately; replaying the same large request
     // adds long UI stalls and can leave several expensive requests in flight.
@@ -1066,9 +1085,9 @@ export async function compact(messages, options) {
         try {
             const result = stream({
                 provider: options.provider,
-                model: summaryModel.id,
-                messages: summaryMessages,
-                maxTokens: summaryOutputTokens,
+                model: request.modelId,
+                messages: request.summaryMessages,
+                maxTokens: request.outputTokens,
                 apiKey: options.apiKey,
                 accountId: options.accountId,
                 projectId: options.projectId,
@@ -1112,6 +1131,20 @@ export async function compact(messages, options) {
             if (options.signal?.aborted || (err instanceof Error && err.name === "AbortError")) {
                 throw err;
             }
+            if (canFallBackToActiveModel && isModelUnavailableFailure(err)) {
+                // The cheaper model was rejected outright: summarize on the model the
+                // session is already using, instead of dropping to the much weaker
+                // extractive fallback.
+                canFallBackToActiveModel = false;
+                log("WARN", "compaction", `Summary model unavailable — retrying on the active model`, {
+                    summaryModel: request.modelId,
+                    activeModel: options.model,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                request = prepareSummaryRequest(options.model);
+                attempt--; // A rejected model is not one of the empty-response retries.
+                continue;
+            }
             log("WARN", "compaction", err instanceof SummaryTimeoutError
                 ? `Summary LLM call timed out after ${SUMMARY_ATTEMPT_TIMEOUT_MS}ms — using fallback`
                 : `Summary LLM call failed: ${err instanceof Error ? err.message : String(err)}`, { attempt: String(attempt), timeoutMs: String(SUMMARY_ATTEMPT_TIMEOUT_MS) });
@@ -1122,6 +1155,9 @@ export async function compact(messages, options) {
             attemptController.abort();
         }
     }
+    // Report the selection of the request that actually ran (the active model's
+    // after a fallback).
+    const { contextSelection, selectedMessages } = request;
     // Fallback: preserve prior compacted memory and append a fresh extractive update.
     if (summaryText.length === 0) {
         log("WARN", "compaction", `All summary attempts failed — using fallback extractive summary`);