@pi-archimedes/session-name 2.10.3 → 2.11.0

package/README.md

@@ -41,7 +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. Spell it exactly: an unrecognised value isn't validated, and on some providers it means *more* thinking rather than none. |
+| `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.3",
+  "version": "2.11.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/danielcherubini/pi-archimedes.git"
@@ -18,7 +18,7 @@
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@pi-archimedes/core": "2.10.3"
+    "@pi-archimedes/core": "2.11.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.86.0",
@@ -26,9 +26,9 @@
     "@earendil-works/pi-tui": ">=0.86.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.87.0",
-    "@earendil-works/pi-coding-agent": "^0.87.0",
-    "@earendil-works/pi-tui": "^0.87.0",
+    "@earendil-works/pi-ai": "1.2.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
+    "@earendil-works/pi-tui": "1.2.0",
     "typescript": "^6.0.0"
   },
   "pi": {

package/src/index.test.ts

@@ -1,6 +1,8 @@
 import { loadConfig } from "@pi-archimedes/core/settings-io";
+import { diag } from "@pi-archimedes/core/log";
 import { describe, expect, it, vi } from "vitest";
-import { generateTitle, registerSessionName } 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;
@@ -65,6 +67,16 @@ vi.mock("@pi-archimedes/core/settings-io", () => ({
   loadConfig: vi.fn((_namespace, defaults) => defaults),
 }));
 
+// Diagnostics never go to the console (see packages/core/src/log.ts): a write
+// there smears a fullscreen frame and is discarded inside a subagent child. So
+// every "it said something / it said nothing" assertion below watches `diag`.
+vi.mock("@pi-archimedes/core/log", async (importOriginal) => {
+  const real = await importOriginal<typeof import("@pi-archimedes/core/log")>();
+  return { ...real, diag: vi.fn() };
+});
+
+const clearDiag = () => vi.mocked(diag).mockClear();
+
 describe("generateTitle", () => {
   it("generates title, trims quotes and whitespace, and calls pi.setSessionName", async () => {
     const pi = createMockPi();
@@ -116,6 +128,114 @@ describe("generateTitle", () => {
     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({});
+      clearDiag();
+      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(diag).not.toHaveBeenCalled();
+    });
+
+    it.each([["ultra"], ["off"], [""], [42], [true], [{}], [[]]])(
+      "never forwards a non-level: %s",
+      async (raw) => {
+        vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: raw });
+        const ctx = createMockCtx({});
+        clearDiag();
+        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");
+        // The typo is invisible unless it is reported, and the report is the
+        // single log line naming the rejected value.
+        expect(diag).toHaveBeenCalledWith(
+          "session-name",
+          `[archimedes] session-name: ignoring unrecognized reasoning ${JSON.stringify(raw)}`,
+        );
+      },
+    );
+
+    it("sends no reasoning key when the value is null, and says nothing", async () => {
+      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: null });
+      const ctx = createMockCtx({});
+      clearDiag();
+      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(diag).not.toHaveBeenCalled();
+    });
+
+    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({});
+      clearDiag();
+      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(diag).not.toHaveBeenCalled();
+    });
+
+    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.
+      clearDiag();
+      expect(resolveTitleReasoning(undefined)).toBe("minimal");
+      expect(diag).not.toHaveBeenCalled();
+    });
+
+    // 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({
@@ -143,16 +263,16 @@ describe("generateTitle", () => {
     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();
+    clearDiag();
+    await generateTitle(pi as any, createMockCtx({}) as any, onSuccess, onFailure);
+    expect(onFailure).toHaveBeenCalledTimes(failures);
+    // A swallowed failure is only acceptable if it left a trace.
+    expect(diag).toHaveBeenCalledTimes(failures);
+    if (failures === 1) {
+      expect(diag).toHaveBeenCalledWith("session-name", expect.stringContaining(message));
     }
+    expect(onSuccess).not.toHaveBeenCalled();
+    expect(pi.setSessionName).not.toHaveBeenCalled();
   });
 
   it("does not call onFailure when streamSimple returns stopReason === 'aborted'", async () => {
@@ -229,29 +349,28 @@ describe("registerSessionName", () => {
     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();
-    }
+    clearDiag();
+    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);
+    // Every attempt is diagnosable…
+    expect(diag).toHaveBeenCalledTimes(3);
+    expect(diag).toHaveBeenCalledWith("session-name", "[archimedes] session-name failed: 400 boom");
+    // …but the user is told once, at the retry-budget boundary: three lines of
+    // console noise (or three notifications) is not a report, it is spam.
+    expect(notify).toHaveBeenCalledTimes(scenario === "UI" || scenario === "broken UI" ? 1 : 0);
+    if (scenario === "UI") expect(notify).toHaveBeenCalledWith(expect.stringContaining("/name"), "warning");
   });
 });

package/src/index.ts

@@ -1,6 +1,7 @@
 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 { diag, describeError } from "@pi-archimedes/core/log";
 import type { SettingItem } from "@earendil-works/pi-tui";
 
 // ── Config ──────────────────────────────────────────────────────────────────
@@ -19,6 +20,55 @@ const DEFAULT_SESSION_NAME_CONFIG: SessionNameSettings = {
 
 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) {
+    // A typo in a hand-edited settings.json is invisible unless reported, but
+    // the report is for whoever debugs the config — the log file, not the
+    // console (which smears a fullscreen frame and is discarded in a child).
+    diag("session-name", `[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);
 }
@@ -155,7 +205,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,
       {
@@ -168,7 +220,7 @@ export async function generateTitle(
         ],
       },
       {
-        ...(settings.reasoning != null ? { reasoning: settings.reasoning } : {}),
+        ...(reasoning !== null ? { reasoning } : {}),
         cacheRetention: "none",
         sessionId: crypto.randomUUID(),
       },
@@ -180,7 +232,9 @@ export async function generateTitle(
       return;
     }
     if (response.stopReason === "error") {
-      console.error("[archimedes] session-name failed:", response.errorMessage ?? "title request failed");
+      // The user's notice is the single one at the retry-budget boundary (see
+      // registerSessionName); one line per attempt goes to the log.
+      diag("session-name", `[archimedes] session-name failed: ${response.errorMessage ?? "title request failed"}`);
       onFailure();
       return;
     }
@@ -209,7 +263,7 @@ export async function generateTitle(
   } 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);
+    diag("session-name", `[archimedes] session-name failed: ${describeError(e)}`);
     onFailure();
   }
 }