Merge branch 'feature/thinking-level-ui'

Author: TKassis

AGENTS.md

@@ -86,6 +86,7 @@ projects/
 
 - **One flat agent.** For independent/parallel subtasks the agent calls the `subagent` tool from the **pi-subagents** package, which spawns child `pi` CLI processes in the sandbox (the binary resolves from `server/node_modules/.bin`). Specialist scientific agents are seeded into each project's `sandbox/.pi/agents/*.md` from `server/src/agent/subagents.ts` (write-if-missing; user edits win). Budget gating + cost ledgering for child runs lives in `server/src/agent/subagent-bridge.ts`.
 - **Interview tool (clarifying questions).** The `interview` custom tool (`server/src/agent/interview.ts`) blocks the run on a pending-answer promise; the questions ride the normal `tool_start` SSE frame and the chat UI renders them as an inline form (`web/src/components/interview-form.tsx`), POSTing answers to `/sessions/:id/interview/:toolCallId`. Tool `promptGuidelines` + the seeded `AGENTS.md` push the agent to interview liberally before assuming. Question schema mirrors pi-interview (single/multi/text/image/info, recommended/conviction/weight, code `content`, image/table/mermaid/chart/html `media`); user-uploaded images return to the model as image blocks. Deliberately NOT exposed to sub-agent child processes — they are headless and must not block on user input.
+- **Thinking level.** Each chat tab has a per-run thinking-level selector (`web/src/components/thinking-selector.tsx`, default `high`); the run body's `thinkingLevel` is validated by `server/src/agent/thinking.ts` and applied via Pi's `session.setThinkingLevel()` after `setModel`. Ollama and Fusion runs send no level (chip disabled). Caveat: like `setModel`, Pi's `setThinkingLevel` also persists the value as the **global default** in `~/.pi/agent/settings.json` — so the last level picked in any tab becomes the starting level for subagent child `pi` processes and for the user's own `pi` CLI. Pin a `thinking` level in a specialist's frontmatter if a subagent must not inherit it.
 - **Modal remote compute (`modal_run`).** Gated on `MODAL_TOKEN_ID`/`MODAL_TOKEN_SECRET` (managed live via `/credentials`; `modalConfigured()` in `server/src/config.ts`). `server/src/agent/modal-tool.ts` is an in-process custom tool, registered in `session-registry.ts` only when configured. It uses the `modal` JS SDK to create an isolated Sandbox on a chosen instance (`server/src/agent/modal-instances.ts` catalogue — `cpu`→`h100`, with GPU string + hourly rate), stages `files_in`, runs the command, copies `files_out` back into the local sandbox (which stays the canonical filesystem — no split-brain), and ledgers wall-time × rate as a `compute` row. The per-chat instance is picked in the UI (`web/src/components/compute-selector.tsx`, gated on `modalConfigured`) and threaded through the run body → `setSessionComputeTarget` → the tool's session default. Like `interview`, it is an in-process custom tool, so it is NOT seen by sub-agent child `pi` processes; promoting it to a Pi package (mirroring web-access) would extend it to them. No secrets are injected into the sandbox by default.
 - **OpenRouter cost** is read from Pi's `usage.cost` (computed from `model.cost`). For synthesized OpenRouter models the pricing comes from `web/src/data/models.json`; keep that catalogue current for accurate cost.
 - **Node ≥ 22.19** is what Pi targets; lower 22.x usually works but emits an `EBADENGINE` warning. Node < 22 (e.g. v20) fails to build/install the packages, so `start.sh` refuses to run on it.

server/src/agent/thinking.ts

@@ -0,0 +1,19 @@
+/**
+ * Thinking-level validation for the run endpoint. Pi's session clamps the
+ * level per model capability; this only guards the untrusted wire value.
+ */
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+
+export const THINKING_LEVELS: readonly ThinkingLevel[] = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+] as const;
+
+/** The value as a ThinkingLevel, or undefined if it isn't one (caller keeps the session's current level). */
+export function parseThinkingLevel(value: unknown): ThinkingLevel | undefined {
+  return THINKING_LEVELS.includes(value as ThinkingLevel) ? (value as ThinkingLevel) : undefined;
+}

server/src/api/sessions.ts

@@ -7,20 +7,32 @@
  * frame sourced from Pi's per-session usage accounting.
  */
 import type { FastifyInstance } from "fastify";
-import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { activePaths } from "../projects.ts";
 import { corsResponseHeaders } from "../cors.ts";
 import { currentProjectId } from "../scope.ts";
 import { toClientFrame, type ClientFrame } from "../agent/events.ts";
-import { resolveModel } from "../agent/models.ts";
 import { setFusionConfig } from "../agent/fusion-bridge.ts";
+import {
+  pendingInterviewFor,
+  resolveInterview,
+  validateAnswer,
+  type InterviewAnswer,
+} from "../agent/interview.ts";
 import { setSessionComputeTarget } from "../agent/modal-tool.ts";
+import { resolveModel } from "../agent/models.ts";
+import {
+  findSessionFile,
+  toNotebook,
+  toShellScript,
+} from "../agent/session-export.ts";
+import { toHistory } from "../agent/session-history.ts";
 import {
   createSession,
   getModelRegistry,
   getSession,
   listSessions,
 } from "../agent/session-registry.ts";
+import { parseThinkingLevel } from "../agent/thinking.ts";
 import {
   addTurnUsage,
   emptySnapshot,
@@ -31,18 +43,6 @@ import {
   snapshotMax,
   type CostSnapshot,
 } from "../cost/ledger.ts";
-import {
-  findSessionFile,
-  toNotebook,
-  toShellScript,
-} from "../agent/session-export.ts";
-import { toHistory } from "../agent/session-history.ts";
-import {
-  pendingInterviewFor,
-  resolveInterview,
-  validateAnswer,
-  type InterviewAnswer,
-} from "../agent/interview.ts";
 
 function snapshot(session: { getSessionStats(): { cost: number; tokens: { input: number; output: number; cacheRead: number; total: number } } }): CostSnapshot {
   const s = session.getSessionStats();
@@ -321,8 +321,10 @@ export async function registerSessionRoutes(app: FastifyInstance): Promise<void>
             }
           }
         }
-        if (body.thinkingLevel) {
-          session.setThinkingLevel(body.thinkingLevel as ThinkingLevel);
+        if (body.thinkingLevel !== undefined) {
+          const level = parseThinkingLevel(body.thinkingLevel);
+          if (level) session.setThinkingLevel(level);
+          else req.log.warn({ thinkingLevel: body.thinkingLevel }, "ignoring invalid thinkingLevel");
         }
 
         // Take over the socket for Server-Sent Events.

server/test/thinking.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { parseThinkingLevel, THINKING_LEVELS } from "../src/agent/thinking.ts";
+
+describe("parseThinkingLevel", () => {
+  it("accepts every Pi level", () => {
+    expect(THINKING_LEVELS).toEqual(["off", "minimal", "low", "medium", "high", "xhigh"]);
+    for (const level of THINKING_LEVELS) {
+      expect(parseThinkingLevel(level)).toBe(level);
+    }
+  });
+
+  it("rejects unknown strings and non-strings", () => {
+    expect(parseThinkingLevel("ultra")).toBeUndefined();
+    expect(parseThinkingLevel("OFF")).toBeUndefined();
+    expect(parseThinkingLevel("")).toBeUndefined();
+    expect(parseThinkingLevel(undefined)).toBeUndefined();
+    expect(parseThinkingLevel(null)).toBeUndefined();
+    expect(parseThinkingLevel(3)).toBeUndefined();
+    expect(parseThinkingLevel({ level: "high" })).toBeUndefined();
+  });
+});

web/src/components/chat-tab.tsx

@@ -30,6 +30,11 @@ import {
   type Model,
 } from "@/components/model-selector";
 import { ComputeSelector, type ModalInstance } from "@/components/compute-selector";
+import {
+  DEFAULT_THINKING_LEVEL,
+  ThinkingSelector,
+  type ThinkingLevel,
+} from "@/components/thinking-selector";
 import { apiFetch } from "@/lib/projects";
 import { onChatPrefill } from "@/lib/chat-prefill";
 import { buildSkillsContext, type Skill } from "@/components/skills-selector";
@@ -80,9 +85,22 @@ interface QueuedMessage {
   files: string[];
   /** Selected Modal compute instance id at enqueue time (null = local). */
   computeTarget: string | null;
+  /** Thinking level at enqueue time (null = model doesn't support one). */
+  thinkingLevel: ThinkingLevel | null;
   timestamp: number;
 }
 
+/** Models whose runs must NOT carry a thinkingLevel: Ollama models are built
+ *  with reasoning:false (Pi clamps to off) and Fusion rewrites the wire body,
+ *  so a level is meaningless there. Mirrors isOllama in model-selector.tsx. */
+function thinkingUnsupported(model: { id: string; provider?: string }): boolean {
+  return (
+    model.provider === "Ollama" ||
+    model.id.startsWith("ollama/") ||
+    model.id.startsWith("fusion/")
+  );
+}
+
 function BudgetBanner({
   state,
   totalUsd,
@@ -382,6 +400,9 @@ function ChatInput({
   onModelChange,
   selectedComputeTarget,
   onComputeTargetChange,
+  thinkingLevel,
+  onThinkingLevelChange,
+  thinkingDisabled,
   modalConfigured,
   onUploadFiles,
   allSkills,
@@ -412,6 +433,9 @@ function ChatInput({
   onModelChange: (model: Model) => void;
   selectedComputeTarget: ModalInstance | null;
   onComputeTargetChange: (instance: ModalInstance | null) => void;
+  thinkingLevel: ThinkingLevel;
+  onThinkingLevelChange: (level: ThinkingLevel) => void;
+  thinkingDisabled: boolean;
   modalConfigured: boolean;
   onUploadFiles: (files: FileList | File[], paths?: string[]) => Promise<string[]>;
   allSkills: Skill[];
@@ -686,6 +710,11 @@ function ChatInput({
                 selected={selectedModel}
                 onChange={onModelChange}
               />
+              <ThinkingSelector
+                selected={thinkingLevel}
+                onChange={onThinkingLevelChange}
+                disabled={thinkingDisabled}
+              />
               <ComputeSelector
                 selected={selectedComputeTarget}
                 onChange={onComputeTargetChange}
@@ -910,6 +939,8 @@ export const ChatTab = forwardRef<ChatTabHandle, ChatTabProps>(function ChatTab(
   // Per-tab settings
   const [selectedModel, setSelectedModel] = useState<Model>(DEFAULT_MODEL);
   const [selectedComputeTarget, setSelectedComputeTarget] = useState<ModalInstance | null>(null);
+  const [thinkingLevel, setThinkingLevel] = useState<ThinkingLevel>(DEFAULT_THINKING_LEVEL);
+  const thinkingDisabled = thinkingUnsupported(selectedModel);
   const [modalConfigured, setModalConfigured] = useState(false);
   const [attachedFiles, setAttachedFiles] = useState<string[]>([]);
   const [selectedDbs, setSelectedDbs] = useState<Database[]>([]);
@@ -995,6 +1026,7 @@ export const ChatTab = forwardRef<ChatTabHandle, ChatTabProps>(function ChatTab(
         },
         next.model.fusionConfig,
         next.computeTarget ?? undefined,
+        next.thinkingLevel ?? undefined,
       );
     }, 0);
     return () => window.clearTimeout(id);
@@ -1035,11 +1067,12 @@ export const ChatTab = forwardRef<ChatTabHandle, ChatTabProps>(function ChatTab(
           skills: [...selectedSkills],
           files: [...attachedFiles],
           computeTarget: selectedComputeTarget?.id ?? null,
+          thinkingLevel: thinkingDisabled ? null : thinkingLevel,
           timestamp: Date.now(),
         },
       ]);
     },
-    [messageQueue.length, selectedModel, selectedDbs, selectedSkills, attachedFiles, selectedComputeTarget],
+    [messageQueue.length, selectedModel, selectedDbs, selectedSkills, attachedFiles, selectedComputeTarget, thinkingDisabled, thinkingLevel],
   );
 
   const handleSend = useCallback(
@@ -1058,6 +1091,7 @@ export const ChatTab = forwardRef<ChatTabHandle, ChatTabProps>(function ChatTab(
           },
           selectedModel.fusionConfig,
           selectedComputeTarget?.id,
+          thinkingDisabled ? undefined : thinkingLevel,
         );
       const route = routeSubmit(isStreaming, intent);
       if (route === "queue") {
@@ -1090,6 +1124,8 @@ export const ChatTab = forwardRef<ChatTabHandle, ChatTabProps>(function ChatTab(
       selectedDbs,
       selectedSkills,
       attachedFiles,
+      thinkingDisabled,
+      thinkingLevel,
     ],
   );
 
@@ -1106,7 +1142,14 @@ export const ChatTab = forwardRef<ChatTabHandle, ChatTabProps>(function ChatTab(
       stop,
       sendQuick: async (prompt: string) => {
         if (budgetState === "exceeded") return;
-        await send(prompt, selectedModel.id, undefined, selectedModel.fusionConfig, selectedComputeTarget?.id);
+        await send(
+          prompt,
+          selectedModel.id,
+          undefined,
+          selectedModel.fusionConfig,
+          selectedComputeTarget?.id,
+          thinkingDisabled ? undefined : thinkingLevel,
+        );
       },
       launchWorkflow: async (prompt, model, suggestedSkills, uploadedFiles) => {
         if (budgetState === "exceeded") return;
@@ -1126,10 +1169,20 @@ export const ChatTab = forwardRef<ChatTabHandle, ChatTabProps>(function ChatTab(
           },
           model.fusionConfig,
           selectedComputeTarget?.id,
+          thinkingUnsupported(model) ? undefined : thinkingLevel,
         );
       },
     }),
-    [send, stop, budgetState, selectedModel.id, selectedModel.fusionConfig, selectedComputeTarget?.id],
+    [
+      send,
+      stop,
+      budgetState,
+      selectedModel.id,
+      selectedModel.fusionConfig,
+      selectedComputeTarget?.id,
+      thinkingDisabled,
+      thinkingLevel,
+    ],
   );
 
   // Background tabs stay mounted (so streaming + queue auto-send continue,
@@ -1234,6 +1287,9 @@ export const ChatTab = forwardRef<ChatTabHandle, ChatTabProps>(function ChatTab(
             onModelChange={setSelectedModel}
             selectedComputeTarget={selectedComputeTarget}
             onComputeTargetChange={setSelectedComputeTarget}
+            thinkingLevel={thinkingLevel}
+            onThinkingLevelChange={setThinkingLevel}
+            thinkingDisabled={thinkingDisabled}
             modalConfigured={modalConfigured}
             onUploadFiles={uploadFiles}
             allSkills={allSkills}

web/src/components/thinking-selector.test.tsx

@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { ThinkingSelector, THINKING_LEVELS } from "./thinking-selector";
+
+describe("ThinkingSelector", () => {
+  it("shows the current level on the chip", () => {
+    render(<ThinkingSelector selected="high" onChange={() => {}} />);
+    expect(screen.getByText("High")).toBeInTheDocument();
+  });
+
+  it("lists all six levels and fires onChange with the picked one", async () => {
+    const user = userEvent.setup();
+    const onChange = vi.fn();
+    render(<ThinkingSelector selected="high" onChange={onChange} />);
+    await user.click(screen.getByRole("button"));
+    // Chip + popover row can both show the selected label — use getAllByText.
+    for (const level of THINKING_LEVELS) {
+      expect(screen.getAllByText(level.label).length).toBeGreaterThan(0);
+    }
+    await user.click(screen.getByText("XHigh"));
+    expect(onChange).toHaveBeenCalledWith("xhigh");
+  });
+
+  it("when disabled: shows Off, does not open, never fires onChange", async () => {
+    const user = userEvent.setup();
+    const onChange = vi.fn();
+    render(<ThinkingSelector selected="high" onChange={onChange} disabled />);
+    expect(screen.getByText("Off")).toBeInTheDocument();
+    await user.click(screen.getByRole("button"));
+    expect(screen.queryByText("Medium")).not.toBeInTheDocument();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});