@pi-archimedes/session-name 2.10.3 → 2.10.4

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.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.3"
+    "@pi-archimedes/core": "2.10.4"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.86.0",

package/src/index.test.ts

@@ -1,6 +1,7 @@
 import { loadConfig } from "@pi-archimedes/core/settings-io";
 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;
@@ -116,6 +117,132 @@ 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({});
+      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({

package/src/index.ts

@@ -19,6 +19,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) {
+    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);
 }
@@ -155,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,
       {
@@ -168,7 +219,7 @@ export async function generateTitle(
         ],
       },
       {
-        ...(settings.reasoning != null ? { reasoning: settings.reasoning } : {}),
+        ...(reasoning !== null ? { reasoning } : {}),
         cacheRetention: "none",
         sessionId: crypto.randomUUID(),
       },