@pi-archimedes/session-name 2.10.2 → 2.10.4

package/README.md

@@ -31,7 +31,8 @@ After installing Pi, choose one installation command above, then `cd` into your
 - After the first user + assistant exchange settles, it takes the first exchange (500 characters per side), asks a model to write a 3–8-word title, caps it at 80 characters, and sets the session name — with a final re-check so a name you set yourself can never be overwritten.
 - **Manual names win.** If you named the session (`--name` or `/name`), naming is skipped, and it re-checks before writing.
 - **It uses your current model unless you configure another.** The title is a separate model call outside the main run — with its own cost, **not reflected in the footer's totals**. A `model` setting (e.g. a cheap model) avoids spending your main model on titles.
-- **Skips and retries** — Ephemeral sessions (no session file) are skipped; if the model has no configured auth, the call is skipped. Transient failures print to the console and re-try on later `agent_end` events, giving up for the session after three. It is non-blocking and unobtrusive, but "silent" is too strong: failures are logged.
+- **Failures tell you.** A failed title request is retried on a later turn, and the provider's error is logged as `[archimedes] session-name failed: <provider error>`. After three failures in one session it stops trying and shows a single warning: *Session naming failed 3 times. Check the model configuration or use /name.* The warning is skipped when there's no UI to show it in (`pi -p`) or if you named the session in the meantime. Cancelling a request doesn't count as a failure, and neither does a session that's replaced or torn down while a title is in flight.
+- **Skips** — Ephemeral sessions (no session file) are skipped, and so is a model with no configured auth. Neither counts against the three attempts.
 
 ## Settings
 
@@ -40,6 +41,9 @@ After installing Pi, choose one installation command above, then `cd` into your
 | Setting | Type | Default | Description |
 |---------|------|---------|-------------|
 | `model` | string | _(current model)_ | Model used for title generation (e.g. `openai/gpt-4o-mini`). Canonical `provider/id`, bare IDs, and thinking-suffix forms are all resolved. Empty = current model. |
+| `reasoning` | string \| null | `minimal` | Thinking level for the title request: `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Set `null` to omit the option entirely — that's the fix for a provider that rejects thinking levels outright, which shows up as the naming warning plus a `400 Invalid request parameters` line in the log. Case and stray spaces are tolerated (`" Minimal "` works). Anything unrecognised is ignored in favour of the default and logged as `[archimedes] session-name: ignoring unrecognized reasoning <value>` — it is never sent to the provider, because what an unknown level *means* is provider-dependent: some read it as more thinking, some reject the request, and we'd rather not depend on which. |
+
+`model` is also editable in the `/archimedes` panel (**Model for naming** — Enter to type, blank to go back to the current model); `reasoning` is JSON-only.
 
 On/off is managed by the suite: toggle via `/plugins` (`archimedes.sessionName.enabled`, default on).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/session-name",
-  "version": "2.10.2",
+  "version": "2.10.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/danielcherubini/pi-archimedes.git"
@@ -18,7 +18,7 @@
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@pi-archimedes/core": "2.10.2"
+    "@pi-archimedes/core": "2.10.4"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.86.0",

package/src/index.test.ts

@@ -1,5 +1,7 @@
+import { loadConfig } from "@pi-archimedes/core/settings-io";
 import { describe, expect, it, vi } from "vitest";
-import { generateTitle } from "./index.js";
+import { thinkingBudgetForLevel } from "@earendil-works/pi-ai/api/simple-options";
+import { generateTitle, registerSessionName, resolveTitleReasoning } from "./index.js";
 
 function createMockPi(sessionName: string | undefined = undefined) {
   let currentName = sessionName;
@@ -60,6 +62,10 @@ function createMockCtx(options: {
   };
 }
 
+vi.mock("@pi-archimedes/core/settings-io", () => ({
+  loadConfig: vi.fn((_namespace, defaults) => defaults),
+}));
+
 describe("generateTitle", () => {
   it("generates title, trims quotes and whitespace, and calls pi.setSessionName", async () => {
     const pi = createMockPi();
@@ -101,6 +107,142 @@ describe("generateTitle", () => {
     expect(onFailure).not.toHaveBeenCalled();
   });
 
+  it.each(["low", null])("uses configured reasoning %s", async (reasoning) => {
+    vi.mocked(loadConfig).mockReturnValueOnce({ reasoning });
+    const ctx = createMockCtx({});
+    await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+
+    const options = (ctx.modelRegistry.streamSimple as any).mock.calls[0][2];
+    if (reasoning === null) expect(options).not.toHaveProperty("reasoning");
+    else expect(options.reasoning).toBe(reasoning);
+  });
+
+  // Issue #86: settings.json is hand-edited strict JSON, so the value can be
+  // anything. A non-level must never reach the provider — see the pin at the
+  // end of this block for what that costs.
+  describe("reasoning validation", () => {
+    it("passes every real thinking level through untouched", async () => {
+      for (const reasoning of ["minimal", "low", "medium", "high", "xhigh", "max"]) {
+        vi.mocked(loadConfig).mockReturnValueOnce({ reasoning });
+        const ctx = createMockCtx({});
+        await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+
+        const options = (ctx.modelRegistry.streamSimple as any).mock.calls[0][2];
+        expect(options.reasoning).toBe(reasoning);
+      }
+    });
+
+    it.each(["Minimal", "  high  ", "MAX"])("tolerates casing and padding: %s", async (raw) => {
+      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: raw });
+      const ctx = createMockCtx({});
+      const log = vi.spyOn(console, "error").mockImplementation(() => {});
+      try {
+        await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+        expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning).toBe(
+          raw.trim().toLowerCase(),
+        );
+        expect(log).not.toHaveBeenCalled();
+      } finally {
+        log.mockRestore();
+      }
+    });
+
+    it.each([["ultra"], ["off"], [""], [42], [true], [{}], [[]]])(
+      "never forwards a non-level: %s",
+      async (raw) => {
+        vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: raw });
+        const ctx = createMockCtx({});
+        const log = vi.spyOn(console, "error").mockImplementation(() => {});
+        try {
+          await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+
+          const sent = (ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning;
+          // Invalid config behaves like absent config: the documented default.
+          expect(sent).toBe("minimal");
+          expect(log).toHaveBeenCalledWith(
+            "[archimedes] session-name: ignoring unrecognized reasoning",
+            JSON.stringify(raw),
+          );
+        } finally {
+          log.mockRestore();
+        }
+      },
+    );
+
+    it("sends no reasoning key when the value is null, and says nothing", async () => {
+      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: null });
+      const ctx = createMockCtx({});
+      const log = vi.spyOn(console, "error").mockImplementation(() => {});
+      try {
+        await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+        expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2]).not.toHaveProperty("reasoning");
+        expect(log).not.toHaveBeenCalled();
+      } finally {
+        log.mockRestore();
+      }
+    });
+
+    it("keeps the default when the setting is absent entirely, and says nothing", async () => {
+      // loadConfig merges the package default, so an absent key arrives as
+      // "minimal" — the common path must stay silent. A regression that warned
+      // on every default-configured session would otherwise pass the suite.
+      const ctx = createMockCtx({});
+      const log = vi.spyOn(console, "error").mockImplementation(() => {});
+      try {
+        await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+        expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning).toBe("minimal");
+        expect(log).not.toHaveBeenCalled();
+      } finally {
+        log.mockRestore();
+      }
+    });
+
+    it("treats undefined like absent config, without warning", () => {
+      // Direct call: the generateTitle path can't produce this, since
+      // loadConfig fills the default in, but the helper is exported.
+      const log = vi.spyOn(console, "error").mockImplementation(() => {});
+      try {
+        expect(resolveTitleReasoning(undefined)).toBe("minimal");
+        expect(log).not.toHaveBeenCalled();
+      } finally {
+        log.mockRestore();
+      }
+    });
+
+    // Pin the invariant against the arithmetic that makes this dangerous. Of
+    // pi-ai's adapters that export a streamSimple, three never call
+    // `clampThinkingLevel` — anthropic-messages, bedrock-converse-stream, and
+    // pi-messages (Radius) — so a forwarded non-level reaches their level
+    // tables verbatim:
+    //   - adaptive-thinking models: mapThinkingLevelToEffort has no `off` case
+    //     and its `default:` returns "high" — a typo silently buys maximum
+    //     effort on a one-line title. This is the real damage: nothing fails.
+    //   - budget-based models: thinkingBudgetForLevel's table has four keys, so
+    //     a non-level yields undefined, which propagates into max_tokens as NaN
+    //     (serialized `null`) and the provider rejects it. Silly, but loud.
+    // We can't fix pi's tables, so guarantee we never hand it a non-level:
+    // whatever we send must be a level the budget table recognises.
+    it("resolved reasoning is always a level the Anthropic budget table knows", () => {
+      // The hazard, read from pi-ai itself: these levels have a budget, junk doesn't.
+      const levels = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
+      for (const level of levels) {
+        expect(thinkingBudgetForLevel(level)).toBeTypeOf("number");
+      }
+      const junk: unknown[] = ["ultra", "MINIMAL", "off", "", "Max ", 42, true, {}, []];
+      for (const value of junk) {
+        expect(thinkingBudgetForLevel(value as never)).toBeUndefined();
+      }
+
+      // Whatever the setting holds, the value we forward is always safe to send.
+      for (const raw of [...levels, ...junk, null, undefined]) {
+        const resolved = resolveTitleReasoning(raw);
+        if (resolved === null) continue; // omitted → no level requested
+        expect(levels).toContain(resolved);
+        expect(thinkingBudgetForLevel(resolved)).toBeTypeOf("number");
+      }
+    });
+  });
+
   it("triggers onFailure when streamSimple returns stopReason === 'error'", async () => {
     const pi = createMockPi();
     const ctx = createMockCtx({
@@ -120,6 +262,26 @@ describe("generateTitle", () => {
     expect(onFailure).toHaveBeenCalledTimes(1);
   });
 
+  it.each([
+    ["This extension ctx is stale after session replacement or reload.", 0],
+    ["Unexpected lookup failure", 1],
+  ] as const)("handles lookup errors: %s", async (message, failures) => {
+    const pi = createMockPi();
+    pi.getSessionName.mockImplementation(() => { throw new Error(message); });
+    const onSuccess = vi.fn();
+    const onFailure = vi.fn();
+    const log = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      await generateTitle(pi as any, createMockCtx({}) as any, onSuccess, onFailure);
+      expect(onFailure).toHaveBeenCalledTimes(failures);
+      expect(log).toHaveBeenCalledTimes(failures);
+      expect(onSuccess).not.toHaveBeenCalled();
+      expect(pi.setSessionName).not.toHaveBeenCalled();
+    } finally {
+      log.mockRestore();
+    }
+  });
+
   it("does not call onFailure when streamSimple returns stopReason === 'aborted'", async () => {
     const pi = createMockPi();
     const ctx = createMockCtx({
@@ -185,3 +347,38 @@ describe("generateTitle", () => {
     expect(onFailure).not.toHaveBeenCalled();
   });
 });
+
+describe("registerSessionName", () => {
+  it.each(["UI", "no UI", "named", "stale", "stale UI", "broken UI"])("reports exhaustion safely: %s", async (scenario) => {
+    const pi = createMockPi();
+    registerSessionName(pi as any);
+    const agentEnd = pi.on.mock.calls.find(([event]) => event === "agent_end")![1];
+    const error = { stopReason: "error", content: [], errorMessage: "400 boom" };
+    const notify = vi.fn();
+    const ctx = { ...createMockCtx({ streamSimpleResult: error }), hasUI: scenario !== "no UI", ui: { notify } };
+    const log = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      await agentEnd({}, ctx);
+      await agentEnd({}, ctx);
+      let finish!: (response: any) => void;
+      const pending = new Promise((resolve) => { finish = resolve; });
+      ctx.modelRegistry.streamSimple.mockReturnValueOnce({ result: vi.fn(() => pending) });
+      await agentEnd({}, ctx);
+      // Change the session/UI while the third request is still pending.
+      if (scenario === "named") pi.setSessionName("Manual name");
+      if (scenario === "stale") pi.getSessionName.mockImplementation(() => { throw new Error("stale context"); });
+      if (scenario === "stale UI") Object.defineProperty(ctx, "hasUI", { get: () => { throw new Error("stale UI"); } });
+      if (scenario === "broken UI") notify.mockImplementation(() => { throw new Error("UI failed"); });
+      finish(error);
+      await pending;
+      await agentEnd({}, ctx);
+      expect(ctx.modelRegistry.streamSimple).toHaveBeenCalledTimes(3);
+      expect(log).toHaveBeenCalledTimes(3);
+      expect(log).toHaveBeenCalledWith("[archimedes] session-name failed:", "400 boom");
+      expect(notify).toHaveBeenCalledTimes(scenario === "UI" || scenario === "broken UI" ? 1 : 0);
+      if (scenario === "UI") expect(notify).toHaveBeenCalledWith(expect.stringContaining("/name"), "warning");
+    } finally {
+      log.mockRestore();
+    }
+  });
+});

package/src/index.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ThinkingLevel } from "@earendil-works/pi-ai";
 import { loadConfig } from "@pi-archimedes/core/settings-io";
 import type { SettingItem } from "@earendil-works/pi-tui";
 
@@ -8,14 +9,65 @@ export interface SessionNameSettings {
   // suite-managed by meta's plugin gate (archimedes.sessionName.enabled — see ADR 0012); session-name never reads this
   enabled?: boolean | undefined;
   model?: string | undefined;
+  reasoning?: ThinkingLevel | null | undefined;
 }
 
 const DEFAULT_SESSION_NAME_CONFIG: SessionNameSettings = {
   model: undefined,
+  reasoning: "minimal",
 };
 
 const NAMESPACE = "archimedes.sessionName";
 
+/** The thinking levels we accept — pi-ai's set, minus `off` (see below). */
+const REASONING_LEVELS: readonly ThinkingLevel[] = [
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+];
+
+/**
+ * Decide what reasoning level the title request asks for, given whatever was
+ * found in settings.json.
+ *
+ * `settings.json` is hand-edited strict JSON and `loadConfig` returns untyped
+ * JSON, so the declared `ThinkingLevel` type narrows nothing at runtime: a
+ * wrong case, a stray space, or a typo all get through. Junk must not be
+ * forwarded, because pi cannot rescue it everywhere — of the ten adapters that
+ * export a `streamSimple`, three never call `clampThinkingLevel`:
+ * `anthropic-messages`, `bedrock-converse-stream`, and `pi-messages` (Radius,
+ * which forwards the level verbatim to its backend). On the Anthropic pair an
+ * unknown value hits `mapThinkingLevelToEffort`, whose `default:` returns
+ * `"high"`: a typo silently buys maximum effort on a one-line title. On
+ * budget-based Claude it instead misses the four-key budget table, and the
+ * resulting `undefined` reaches the provider as an invalid `max_tokens`.
+ *
+ * Outcomes: a real level (casing/padding tolerated) is forwarded; `null` means
+ * omit the option entirely; anything else — including absent — is treated like
+ * an absent setting and gets the default, with a log line so the user can find
+ * the typo. `"off"` is deliberately not accepted: it would be a fourth
+ * spelling of "unset" next to `null` and an absent key, and pi accepts `off` as
+ * no-effort anyway wherever it maps one.
+ */
+export function resolveTitleReasoning(raw: unknown): ThinkingLevel | null {
+  if (raw === null) return null;
+  if (typeof raw === "string") {
+    const value = raw.trim().toLowerCase();
+    const match = REASONING_LEVELS.find((level) => level === value);
+    if (match) return match;
+  }
+  if (raw !== undefined) {
+    console.error(
+      "[archimedes] session-name: ignoring unrecognized reasoning",
+      JSON.stringify(raw),
+    );
+  }
+  return DEFAULT_SESSION_NAME_CONFIG.reasoning ?? null;
+}
+
 export function loadSessionNameConfig(): SessionNameSettings {
   return loadConfig(NAMESPACE, DEFAULT_SESSION_NAME_CONFIG);
 }
@@ -152,7 +204,9 @@ export async function generateTitle(
     // 4. Check auth — skip without incrementing failCount if not configured
     if (!ctx.modelRegistry.hasConfiguredAuth(model)) return;
 
-    // 5. Stream simple with built-in auth resolution
+    // 5. Stream simple with built-in auth resolution.
+    // Reasoning is resolved, not forwarded raw: see resolveTitleReasoning().
+    const reasoning = resolveTitleReasoning(settings.reasoning);
     const stream = ctx.modelRegistry.streamSimple(
       model,
       {
@@ -165,7 +219,7 @@ export async function generateTitle(
         ],
       },
       {
-        reasoning: "minimal",
+        ...(reasoning !== null ? { reasoning } : {}),
         cacheRetention: "none",
         sessionId: crypto.randomUUID(),
       },
@@ -177,6 +231,7 @@ export async function generateTitle(
       return;
     }
     if (response.stopReason === "error") {
+      console.error("[archimedes] session-name failed:", response.errorMessage ?? "title request failed");
       onFailure();
       return;
     }
@@ -203,6 +258,8 @@ export async function generateTitle(
     pi.setSessionName(title);
     onSuccess();
   } catch (e) {
+    // Session replacement or print-mode teardown makes an in-flight title irrelevant.
+    if (e instanceof Error && e.message.includes("stale after session replacement")) return;
     console.error("[archimedes] session-name failed:", e);
     onFailure();
   }
@@ -234,7 +291,15 @@ export function registerSessionName(pi: ExtensionAPI) {
 
     // Fire-and-forget: spawn title generation in background so handler
     // returns immediately and the UI becomes responsive.
-    void generateTitle(pi, ctx, () => { hasNamed = true; }, () => { failCount++; });
+    void generateTitle(pi, ctx, () => { hasNamed = true; }, () => {
+      failCount++;
+      if (failCount !== 3) return;
+      try {
+        if (ctx.hasUI && !pi.getSessionName()) {
+          ctx.ui.notify("Session naming failed 3 times. Check the model configuration or use /name.", "warning");
+        }
+      } catch { /* Reporting must not count as another naming failure. */ }
+    });
   });
 }