bermudis-pi-goodies 0.23.2 → 0.23.4

package/README.md

@@ -25,7 +25,7 @@ extensions. One entry point, twelve independent features.
 After publishing the package to npm:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.23.2
+pi install npm:bermudis-pi-goodies@0.23.4
 ```
 
 Remove any old `bermudis-pi-goodies.ts` symlink before reloading Pi. Each
@@ -60,7 +60,13 @@ widget line above the editor shows the cause and clears itself on the first
 success. Transient provider failures (upstream 5xx, stalls, network blips)
 are retried in place — up to three tries with a progressive pause of 1s,
 5s, then 10s — before any of that engages, so a single blip costs nothing;
-rate limits and other 4xx go straight to the pause. Summary log events carry
+rate limits and other 4xx go straight to the pause. A response whose whole
+budget went to reasoning (thinking blocks but no answer — how router models
+like `kilo-auto/free` fail when their random upstream is a thinking model
+that ignores effort hints) gets one in-place retry at a raised 4096-token
+cap before the pause; the retry is logged as a `summary_reasoning_retry`
+event carrying the upstream the router actually picked, so the log names
+who ate the budget. Summary log events carry
 a `kind` field — `bash` or `thinking` — so `jq -r 'select(.type ==
 "summary_request") | [.kind, .outcome] | @tsv'` splits request counts by
 feature. The log at
@@ -74,10 +80,15 @@ there first; e.g. `jq -r 'select(.type == "summary_request") | .outcome'
 
 Two practical notes:
 
-- **Thinking models are handled, non-thinking ones are cheaper.** Requests
-  pin the model's lowest reasoning effort and carry a 512-token budget that
-  covers thinking plus the answer, so reasoning models work; a quick
-  chat-class model still costs the least.
+- **Thinking models are handled, non-thinking ones are cheaper.** The
+  reasoning effort comes from the model's own declared levels — the catalog
+  says what each model supports and the request is clamped to that, in the
+  model's own dialect. Models that declare nothing (routers like
+  `kilo-auto/free`) get the documented floor `low` — never an undocumented
+  word a gateway might silently drop — plus a 512-token budget covering
+  thinking plus the answer, with the raised-cap retry above for upstreams
+  that ignore it. A quick chat-class model still costs the least and can't
+  fail this way.
 - **Privacy:** qualifying commands (longer than 80 characters) are sent —
   first ~2000 characters — to whichever provider hosts the model you chose.
   That is the same trust decision as running an agent session against that
@@ -118,11 +129,12 @@ commands it is logged as a digest, never raw text.
 
 Two honest trade-offs:
 
-- **Separate opt-in, default off every launch.** A bash summary is one request per unique
+- **Separate opt-in, off until you enable it.** A bash summary is one request per unique
   command; a thinking summary recurs for as long as the model reasons.
-  Same provider, different volume — so `thinking-summaries on` asks for
-  that explicitly, for this pi run only (off again next launch, never saved).
-  It takes effect immediately, no `/reload`.
+  Same provider, different volume — so thinking summaries are a separate
+  toggle (`/goodies thinking-summaries on|off`), default off, persisted to
+  `goodies.json` like every other toggle. It takes effect immediately, no
+  `/reload`.
 - **It does not replace the `Thinking...` row itself.** Pi's only seam for
   that text is one global label applied to every assistant message at
   once — updating it mid-stream would rewrite every past thinking row, and

package/clean-tui.ts

@@ -44,11 +44,12 @@ import { Box, Container, Text } from "@earendil-works/pi-tui";
 import { homedir } from "node:os";
 import { readFileSync } from "node:fs";
 import { completeSimple } from "@earendil-works/pi-ai/compat";
-import type {
-  Api,
-  AssistantMessage,
-  Model,
-  ThinkingLevel,
+import {
+  clampThinkingLevel,
+  type Api,
+  type AssistantMessage,
+  type Model,
+  type ThinkingLevel,
 } from "@earendil-works/pi-ai";
 import { logGoodiesEvent, setGoodiesLogPathForTesting } from "./goodies-log.ts";
 import { describeError } from "./json-file.ts";
@@ -424,7 +425,12 @@ const SUMMARY_THRESHOLD_CHARS = 80;
 // old 30-token cap, gpt-oss running its API-default effort returned an empty
 // summary every time. 512 gives reasoning headroom; non-reasoning models
 // stop at the answer's natural end, so the raised cap costs them nothing.
+// When even 512 is out-thought — router models (kilo-auto/free, openrouter
+// routers) hop between upstreams per request and some ignore effort hints
+// entirely — completeSummaryTurn escalates once to the cap below before
+// declaring the empty-summary failure.
 const SUMMARY_MAX_TOKENS = 512;
+const SUMMARY_REASONING_RETRY_MAX_TOKENS = 4096;
 const SUMMARY_PROMPT =
   "Summarize this shell command in less than 13 words, plain English, no quotes, no formatting. " +
   'Examples: "cat >> file << \'EOF\' with 20 lines of log" -> "Appends reboot log to migration file". ' +
@@ -692,6 +698,41 @@ async function resolveSummaryTransport(): Promise<{
   return { model: found, label, apiKey: auth.apiKey, headers };
 }
 
+/** Whether any content block carries non-empty answer text. */
+function hasAnswerText(response: {
+  content: Array<{ type: string; text?: string }>;
+}): boolean {
+  return response.content.some(
+    (c) => c.type === "text" && (c.text ?? "").trim() !== "",
+  );
+}
+
+/**
+ * Whether a textless response looks like "reasoning consumed the shared
+ * completion budget": thinking blocks arrived (their text lives in the
+ * `thinking` field, not `text`), or the provider hit the token ceiling
+ * before any answer existed. Routers (kilo-auto/free, openrouter/*) make
+ * this nondeterministic — every request can land on a different upstream,
+ * and thinking upstreams may ignore reasoning-effort hints outright.
+ */
+function reasoningAteBudget(response: {
+  stopReason: string;
+  content: Array<{
+    type: string;
+    text?: string;
+    thinking?: string;
+    redacted?: boolean;
+  }>;
+}): boolean {
+  if (hasAnswerText(response)) return false;
+  if (response.stopReason === "length") return true;
+  return response.content.some(
+    (c) =>
+      c.type === "thinking" &&
+      ((c.thinking ?? c.text ?? "").trim() !== "" || c.redacted === true),
+  );
+}
+
 /**
  * Convert a pi-ai completion response into a summary string or throw the
  * error shape the shared backoff/log/widget path expects. Extracted from
@@ -702,14 +743,17 @@ async function resolveSummaryTransport(): Promise<{
  *
  * - "aborted" → AbortError (per-request abort, not a provider failure)
  * - "error"   → Error with the provider's errorMessage (truncated) + label
- * - empty text content → Error diagnosing a thinking-model that ate the budget
+ * - empty text after reasoning activity → Error naming the eaten budget
+ *   (completeSummaryTurn has already retried at a raised cap by this point)
+ * - empty text without reasoning activity → the generic thinking-model
+ *   diagnosis
  * - anything else → the joined text content
  */
 export function convertSummaryResponse(
   response: {
     stopReason: string;
     errorMessage?: string;
-    content: Array<{ type: string; text?: string }>;
+    content: Array<{ type: string; text?: string; thinking?: string }>;
   },
   label: string,
 ): string {
@@ -726,10 +770,16 @@ export function convertSummaryResponse(
     .filter((c): c is { type: "text"; text: string } => c.type === "text")
     .map((c) => c.text)
     .join("\n");
-  if (!text.trim())
+  if (!text.trim()) {
+    if (reasoningAteBudget(response)) {
+      throw new Error(
+        `empty summary — ${label} spent the raised token budget on reasoning; try a summary model that can disable thinking`,
+      );
+    }
     throw new Error(
       `empty summary — is ${label} a thinking model that cannot disable thinking?`,
     );
+  }
   return text;
 }
 
@@ -742,60 +792,104 @@ function activeBackend(): SummaryBackend {
   );
 }
 
-// Lowest-effort reasoning, but only where silence is broken: on OpenAI-
-// compatible endpoints a reasoning model with no mapped "off" (Groq's
-// gpt-oss maps off and minimal to null) runs its API-default effort when no
-// reasoning parameter is sent — medium for gpt-oss — which burns the shared
-// completion budget and returns an empty answer. "minimal" clamps to the
-// model's lowest supported level ("low" for gpt-oss). Everything else keeps
-// the absent option: non-reasoning models clamp to "off" (no parameter),
-// models whose catalog maps "off" to a concrete value already disable
-// thinking when nothing is sent, and non-OpenAI adapters enable thinking on
-// truthy values (see the retired no-reasoning note in git history).
+// Lowest-effort reasoning, but only where silence is broken — and always the
+// model's OWN declared capability, never a hardcoded guess:
+//
+//  - Non-reasoning models, non-OpenAI adapters (a truthy effort ENABLES
+//    thinking there), and models whose map gives "off" a concrete wire
+//    value: send nothing. The adapter emits the declared off value itself.
+//  - Models with a capability map: request "minimal". completeSimple clamps
+//    against the map before anything reaches the wire (pi-ai streamSimple),
+//    so the model only ever sees a level it declares, translated to its own
+//    dialect word — whether the catalog says low..max, only off+high, or
+//    maps minimal to something else entirely.
+//  - Map-less models (routers: kilo-auto/free, openrouter/*): there is no
+//    translation layer, so the raw word must be one gateways actually
+//    document. "minimal" is not — OpenRouter-style wires silently drop it
+//    and the random upstream runs its DEFAULT effort, which is exactly the
+//    reasoning-eats-the-budget failure. Send the documented floor "low";
+//    the raised-cap retry absorbs upstreams that ignore even that.
 function summaryReasoning(model: Model<Api>): ThinkingLevel | undefined {
   if (model.api !== "openai-completions" && model.api !== "openai-responses")
     return undefined;
   if (!model.reasoning) return undefined;
   if (typeof model.thinkingLevelMap?.off === "string") return undefined;
+  if (model.thinkingLevelMap === undefined) return "low";
   return "minimal";
 }
 
 /**
  * Run one summary completion through pi-ai, shared by both summary kinds so
- * the reasoning_effort compatibility retry lives in exactly one place.
+ * the reasoning-effort compatibility retry and the reasoning-budget retry
+ * live in exactly one place.
  *
- * Some OpenAI-compatible endpoints validate reasoning_effort against their
- * own enum and reject "minimal" outright — observed on Command Code
- * (commandcode/poolside/*): 400 invalid_request_error, param:"reasoning_effort",
- * accepted values low|medium|high|xhigh|max. "low" is the floor of every known
- * enum, so retry once there before surfacing the failure; an endpoint that
- * rejects "low" too would pause as before.
+ * Retry 1 — enum compatibility: some OpenAI-compatible endpoints validate
+ * reasoning_effort against their own enum and reject "minimal" outright —
+ * observed on Command Code (commandcode/poolside/*): 400 invalid_request_error,
+ * param:"reasoning_effort", accepted values low|medium|high|xhigh|max. "low"
+ * is the floor of every known enum, so retry once there before surfacing the
+ * failure; an endpoint that rejects "low" too would pause as before.
+ *
+ * Retry 2 — reasoning budget: a response with no answer text whose budget
+ * went to thinking (thinking blocks present, or a length cutoff) gets one
+ * second chance at a raised cap. This is the router case (kilo-auto/free):
+ * each request lands on a random pool upstream (DeepSeek, Nemotron, Qwen,
+ * ...) that may ignore the effort hint entirely — no dialect word controls
+ * another vendor's thinking. The retry clamps the effort to the model's
+ * declared floor (never an undeclared word) and raises the cap — the cap is
+ * the lever that works regardless of dialect. Models where summaryReasoning
+ * sent no effort keep it absent: for non-OpenAI adapters a truthy effort
+ * ENABLES thinking. Still empty after this lands as the raised-budget
+ * diagnosis in convertSummaryResponse; the outer timeout still bounds the
+ * whole turn, so a slow retry degrades to the ordinary retryable-timeout
+ * path.
  */
 async function completeSummaryTurn(
   t: Awaited<ReturnType<typeof resolveSummaryTransport>>,
   context: Parameters<typeof completeSimple>[1],
   signal: AbortSignal,
 ): Promise<AssistantMessage> {
-  const options = (reasoning: ThinkingLevel | undefined) => ({
+  const firstEffort = summaryReasoning(t.model);
+  const options = (
+    reasoning: ThinkingLevel | undefined,
+    maxTokens: number = SUMMARY_MAX_TOKENS,
+  ) => ({
     apiKey: t.apiKey,
     headers: t.headers,
-    maxTokens: SUMMARY_MAX_TOKENS,
+    maxTokens,
     signal,
     reasoning,
   });
   // completeSimple does NOT throw for HTTP errors — it returns an
   // AssistantMessage with stopReason:"error" + errorMessage, so the
   // compatibility check inspects the response, not a catch block.
-  const response = await completeSimple(
-    t.model,
-    context,
-    options(summaryReasoning(t.model)),
-  );
+  let response = await completeSimple(t.model, context, options(firstEffort));
   if (
     response.stopReason === "error" &&
     (response.errorMessage ?? "").includes("reasoning_effort")
   ) {
-    return await completeSimple(t.model, context, options("low"));
+    response = await completeSimple(t.model, context, options("low"));
+  }
+  if (reasoningAteBudget(response)) {
+    logGoodiesEvent({
+      type: "summary_reasoning_retry",
+      model: t.label,
+      // The upstream a router actually picked — the response's own model
+      // field is the only way to know who ate the budget.
+      ...(response.responseModel
+        ? { responseModel: response.responseModel }
+        : {}),
+    });
+    response = await completeSimple(
+      t.model,
+      context,
+      options(
+        firstEffort === undefined
+          ? undefined
+          : (clampThinkingLevel(t.model, "low") as ThinkingLevel),
+        SUMMARY_REASONING_RETRY_MAX_TOKENS,
+      ),
+    );
   }
   return response;
 }

package/goodies.ts

@@ -8,8 +8,7 @@
  * State persists to ~/.pi/agent/goodies.json. Toggling a feature writes the
  * config but does NOT unload/reload the extension — every feature is registered
  * at load time, so a toggle needs `/reload` or a new session to take effect.
- * Exceptions read at request time: `summary-model`, and `thinking-summaries`
- * which is session-only (off on every pi launch, never persisted — token spend).
+ * Exceptions read at request time: `summary-model` and `thinking-summaries`.
  */
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -26,16 +25,9 @@ import { rankCandidates } from "./vision-core.ts";
 
 let CONFIG_PATH = join(homedir(), ".pi", "agent", "goodies.json");
 
-/** Session-only flag: thinking summaries default off every pi launch. */
-let sessionThinkingEnabled = false;
-
 export function __setConfigPathForTesting(path: string): void {
   CONFIG_PATH = path;
   config = loadConfig();
-  // Thinking summaries are session-only (default off every pi launch), so a
-  // fresh config scope in tests also means a fresh flag — otherwise an
-  // earlier test's `on` would leak into later ones sharing the process.
-  sessionThinkingEnabled = false;
 }
 
 type FeatureName =
@@ -77,10 +69,10 @@ type Config = Partial<Record<FeatureName, boolean>> & {
    */
   "summary-model"?: string;
   /**
-   * Legacy persisted key. Thinking summaries are now session-only (off on
-   * every pi launch, on only when `/goodies thinking-summaries on` runs in
-   * that pi run) because they can add meaningful token spend. The file key
-   * is ignored; it is deleted on write for migration from older versions.
+   * Whether live thinking summaries are on. Persisted like every other
+   * toggle; read at request time so `/goodies thinking-summaries on|off`
+   * takes effect immediately. Unset means off — the volume (a request per
+   * reasoning run, not per command) is why the default stays off.
    */
   "thinking-summaries"?: boolean;
 };
@@ -185,20 +177,13 @@ export function setSummaryModel(model: string | undefined): void {
 }
 
 export function getThinkingSummariesEnabled(): boolean {
-  return sessionThinkingEnabled; // default off every pi launch
+  return config["thinking-summaries"] === true; // default off when unset
 }
 
 export function setThinkingSummariesEnabled(enabled: boolean): void {
-  sessionThinkingEnabled = enabled;
-  // Migration: drop any stale persisted key from older versions so it can
-  // never revive. Best-effort — a failure must not break the toggle.
-  try {
-    updateConfig((next) => {
-      delete next["thinking-summaries"];
-    });
-  } catch {
-    // ignore: the in-memory flag above already took effect
-  }
+  updateConfig((next) => {
+    next["thinking-summaries"] = enabled;
+  });
 }
 
 // ── Summary-model resolution against pi's model registry ────────────────────
@@ -563,7 +548,7 @@ export default function goodies(pi: ExtensionAPI): void {
         setThinkingSummariesEnabled(value === "on");
         const model = getSummaryModel();
         ctx.ui.notify(
-          `thinking summaries ${value} for this pi run only (off again next launch). ` +
+          `thinking summaries ${value} (persisted). ` +
             (value === "on" && !model
               ? `No summary model set yet — run /goodies summary-model <provider/model> or nothing will happen. `
               : "") +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bermudis-pi-goodies",
-  "version": "0.23.2",
+  "version": "0.23.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bermudi/agent-extensions.git",