@pi-archimedes/session-name 2.11.0 → 2.11.1

package/README.md

@@ -41,7 +41,7 @@ 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. |
+| `reasoning` | string \| null | `minimal` | Thinking level for the title request: `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `off`. Resolved to the nearest level the model supports (warns on change); the option is omitted only when that resolves to `"off"`. `off`/`null` therefore request no thinking but can still send a level on models that exclude it — use `"minimal"` for bounded-small everywhere. Case and stray spaces are tolerated (`" Minimal "` works). Anything unrecognised is ignored in favour of the default and logged. Only supported levels reach the provider: the setting resolves through pi's clamp to the nearest level the model supports. |
 
 `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.
 

package/package.json

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

package/src/index.test.ts

@@ -40,7 +40,9 @@ function createMockCtx(options: {
     },
   ];
 
-  const defaultModel = { provider: "anthropic", id: "claude-3-5-sonnet" };
+  // Reasoning model without a level map: every named level passes clamp
+  // through, so existing assertions on forwarded levels keep holding.
+  const defaultModel = { provider: "anthropic", id: "claude-3-5-sonnet", reasoning: true };
 
   return {
     sessionManager: {
@@ -132,8 +134,10 @@ describe("generateTitle", () => {
   // 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"]) {
+    it("passes every supported thinking level through untouched", async () => {
+      // The mock model has no level map, like the real title model — so only
+      // minimal..high pass through; xhigh/max step down (covered below).
+      for (const reasoning of ["minimal", "low", "medium", "high"]) {
         vi.mocked(loadConfig).mockReturnValueOnce({ reasoning });
         const ctx = createMockCtx({});
         await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
@@ -143,7 +147,19 @@ describe("generateTitle", () => {
       }
     });
 
-    it.each(["Minimal", "  high  ", "MAX"])("tolerates casing and padding: %s", async (raw) => {
+    it.each([["xhigh", "high"], ["MAX", "high"]])("clamps %s to nearest supported %s, warning", async (raw, clamped) => {
+      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(clamped);
+      expect(diag).toHaveBeenCalledWith(
+        "session-name",
+        expect.stringContaining(`using "${clamped}"`),
+      );
+    });
+
+    it.each(["Minimal", "  high  "])("tolerates casing and padding: %s", async (raw) => {
       vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: raw });
       const ctx = createMockCtx({});
       clearDiag();
@@ -154,7 +170,7 @@ describe("generateTitle", () => {
       expect(diag).not.toHaveBeenCalled();
     });
 
-    it.each([["ultra"], ["off"], [""], [42], [true], [{}], [[]]])(
+    it.each([["ultra"], [""], [42], [true], [{}], [[]]])(
       "never forwards a non-level: %s",
       async (raw) => {
         vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: raw });
@@ -174,8 +190,9 @@ describe("generateTitle", () => {
       },
     );
 
-    it("sends no reasoning key when the value is null, and says nothing", async () => {
-      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: null });
+    it.each([["off"], [null]])("omits the key for %s on models that take it", async (reasoning) => {
+      // Default mock has no level map, so "off" is supported and omitted silently.
+      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning });
       const ctx = createMockCtx({});
       clearDiag();
       await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
@@ -183,6 +200,20 @@ describe("generateTitle", () => {
       expect(diag).not.toHaveBeenCalled();
     });
 
+    it("clamps off to minimal with a warning where the model excludes it", async () => {
+      // Muse-spark shape: thinking model whose map excludes "off" (null).
+      const model = { provider: "op", id: "spark", reasoning: true, thinkingLevelMap: { off: null } };
+      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: "off" });
+      const ctx = createMockCtx({ model });
+      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).toHaveBeenCalledWith(
+        "session-name",
+        expect.stringContaining('using "minimal"'),
+      );
+    });
+
     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
@@ -202,6 +233,13 @@ describe("generateTitle", () => {
       expect(diag).not.toHaveBeenCalled();
     });
 
+    it("accepts off for the call site to clamp per model", () => {
+      clearDiag();
+      expect(resolveTitleReasoning("off")).toBe("off");
+      expect(resolveTitleReasoning(" Off ")).toBe("off");
+      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
@@ -221,15 +259,18 @@ describe("generateTitle", () => {
       for (const level of levels) {
         expect(thinkingBudgetForLevel(level)).toBeTypeOf("number");
       }
-      const junk: unknown[] = ["ultra", "MINIMAL", "off", "", "Max ", 42, true, {}, []];
+      const junk: unknown[] = ["ultra", "MINIMAL", "", "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.
+      // Whatever the setting holds, the value reaching clamp is a real level
+      // or "off" — never raw input. "off" is resolved per model at the call
+      // site (nearest supported, warn on change), never forwarded verbatim.
       for (const raw of [...levels, ...junk, null, undefined]) {
         const resolved = resolveTitleReasoning(raw);
         if (resolved === null) continue; // omitted → no level requested
+        if (resolved === "off") continue; // clamped per model at the call site
         expect(levels).toContain(resolved);
         expect(thinkingBudgetForLevel(resolved)).toBeTypeOf("number");
       }

package/src/index.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { ThinkingLevel } from "@earendil-works/pi-ai";
+import { clampThinkingLevel } from "@earendil-works/pi-ai";
+import type { ModelThinkingLevel, 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";
@@ -10,7 +11,7 @@ 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;
+  reasoning?: ThinkingLevel | "off" | null | undefined;
 }
 
 const DEFAULT_SESSION_NAME_CONFIG: SessionNameSettings = {
@@ -20,14 +21,16 @@ 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[] = [
+/** The thinking levels we accept — pi-ai's set, plus `off` (resolved per
+ * model at the call site: omitting is the only portable spelling of none). */
+const REASONING_LEVELS: readonly (ThinkingLevel | "off")[] = [
   "minimal",
   "low",
   "medium",
   "high",
   "xhigh",
   "max",
+  "off",
 ];
 
 /**
@@ -46,14 +49,15 @@ const REASONING_LEVELS: readonly ThinkingLevel[] = [
  * 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.
+ * Outcomes: a real level (casing/padding tolerated) is returned for the call
+ * site to resolve per model; `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
+ * accepted but never forwarded raw: it resolves through pi's
+ * `clampThinkingLevel` like every other level (nearest supported, warn on
+ * change), because unclamped providers map unknown levels to maximum effort.
  */
-export function resolveTitleReasoning(raw: unknown): ThinkingLevel | null {
+export function resolveTitleReasoning(raw: unknown): ThinkingLevel | "off" | null {
   if (raw === null) return null;
   if (typeof raw === "string") {
     const value = raw.trim().toLowerCase();
@@ -206,8 +210,17 @@ export async function generateTitle(
     if (!ctx.modelRegistry.hasConfiguredAuth(model)) return;
 
     // 5. Stream simple with built-in auth resolution.
-    // Reasoning is resolved, not forwarded raw: see resolveTitleReasoning().
-    const reasoning = resolveTitleReasoning(settings.reasoning);
+    // Reasoning is resolved per model, not forwarded raw: see
+    // resolveTitleReasoning(). `clampThinkingLevel` maps to the nearest level
+    // the model supports (warn on change); only an `off` result omits the
+    // option, which is the single portable spelling of none.
+    const resolved = resolveTitleReasoning(settings.reasoning);
+    const requested: ModelThinkingLevel = resolved === null ? "off" : (resolved ?? "minimal");
+    const clamped = clampThinkingLevel(model, requested);
+    if (clamped !== requested) {
+      diag("session-name", `[archimedes] session-name: reasoning "${requested}" is not supported — using "${clamped}"`);
+    }
+    const reasoning = clamped === "off" ? undefined : clamped;
     const stream = ctx.modelRegistry.streamSimple(
       model,
       {
@@ -220,7 +233,7 @@ export async function generateTitle(
         ],
       },
       {
-        ...(reasoning !== null ? { reasoning } : {}),
+        ...(reasoning !== undefined ? { reasoning } : {}),
         cacheRetention: "none",
         sessionId: crypto.randomUUID(),
       },