@huseynsnmz/pi-suite 0.2.2 → 0.2.4

package/packages/subscription/src/session.ts

@@ -0,0 +1,294 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import type { Query, SDKMessage, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { Tool, ToolResultMessage } from "@earendil-works/pi-ai";
+import { MCP_PREFIX, MCP_SERVER, toolUseId } from "./convert.ts";
+import { type ToolResult, ToolServer } from "./mcp.ts";
+import type { ThinkingOption } from "./models.ts";
+import { AsyncQueue } from "./util.ts";
+
+export interface SessionSpec {
+	cwd: string;
+	model: string;
+	systemPrompt: string;
+	tools: Tool[];
+	toolsHash: string;
+	thinkingKey: string;
+	thinking: ThinkingOption;
+	effort?: "low" | "medium" | "high" | "xhigh" | "max";
+	maxOutputTokens?: number;
+	/** pi asked for no prompt caching (cacheRetention "none"). */
+	noCache?: boolean;
+	/** Resume this Claude Code session, cut after `at` when given. Omit for a fresh session. */
+	resume?: { sessionId: string; at?: string };
+	pathToClaudeCodeExecutable?: string;
+	debug?: (msg: string) => void;
+}
+
+const CLIENT_APP = `pi-suite-subscription/${JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version}`;
+
+type CallToolResult = ToolResult;
+export type StartQuery = typeof import("@anthropic-ai/claude-agent-sdk").query;
+
+/** What the provider needs from a Claude Code session; LiveSession is the real one. */
+export interface ClaudeSession {
+	readonly spec: SessionSpec;
+	readonly sessionId: string;
+	readonly systemPrompt: string;
+	model: string;
+	chain: string;
+	count: number;
+	awaiting: Set<string>;
+	servedByClaude: Set<string>;
+	dead: boolean;
+	/** A provider call is reading this session's events; no other call may attach. */
+	busy: boolean;
+	lastUsed: number;
+	readonly events: AsyncQueue<SDKMessage>;
+	readonly exited: Promise<void>;
+	readonly stderr: string;
+	send(content: any[], priority?: "now" | "next" | "later"): void;
+	deliver(result: ToolResultMessage): void;
+	/** Transcript-entry uuid streamed for an API assistant message; waits briefly for its final SDK frame. */
+	entryUuid(messageId: string): Promise<string | undefined>;
+	setModel(model: string): Promise<void>;
+	interrupt(): Promise<void>;
+	close(): void;
+}
+
+/** Environment for the Claude Code child process. */
+export function childEnv(base: Record<string, string | undefined>, spec: SessionSpec): Record<string, string | undefined> {
+	return {
+		...base,
+		// Subscription auth: no inherited key or cloud-provider switch may move Claude Code to API billing.
+		ANTHROPIC_API_KEY: undefined,
+		ANTHROPIC_AUTH_TOKEN: undefined,
+		// The login goes to Anthropic, not to a gateway this shell happens to name.
+		ANTHROPIC_BASE_URL: undefined,
+		ANTHROPIC_CUSTOM_HEADERS: undefined,
+		CLAUDE_CODE_USE_BEDROCK: undefined,
+		CLAUDE_CODE_USE_VERTEX: undefined,
+		CLAUDE_CODE_USE_FOUNDRY: undefined,
+		// Declare this process honestly as an Agent SDK app, even when pi itself runs inside Claude Code.
+		CLAUDECODE: undefined,
+		CLAUDE_CODE_ENTRYPOINT: undefined,
+		CLAUDE_AGENT_SDK_CLIENT_APP: CLIENT_APP,
+		// pi owns context management: no compaction, no output-size cap on tool results.
+		DISABLE_AUTO_COMPACT: "1",
+		DISABLE_COMPACT: "1",
+		MAX_MCP_OUTPUT_TOKENS: "10000000",
+		MCP_TOOL_TIMEOUT: String(7 * 24 * 3600 * 1000),
+		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+		CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
+		CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1",
+		...(spec.noCache ? { DISABLE_PROMPT_CACHING: "1" } : {}),
+		...(spec.maxOutputTokens ? { CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(spec.maxOutputTokens) } : {}),
+	};
+}
+
+/**
+ * One Claude Code process in streaming-input mode, holding one conversation. pi owns the agent
+ * loop: Claude Code's tool calls reach pi's tools through an in-process MCP server whose
+ * handlers park until pi delivers the tool results on its next provider call.
+ */
+export class LiveSession implements ClaudeSession {
+	readonly spec: SessionSpec;
+	readonly sessionId: string;
+	readonly systemPrompt: string;
+	model: string;
+	/** Chain hash and length of the pi transcript this process has consumed. */
+	chain: string;
+	count: number;
+	/** Tool calls of the last step that pi has not answered yet. */
+	awaiting = new Set<string>();
+	/** Tool calls Claude Code answered itself (unknown tool names); pi's results for them are ignored. */
+	servedByClaude = new Set<string>();
+	dead = false;
+	busy = false;
+	lastUsed = Date.now();
+	readonly events = new AsyncQueue<SDKMessage>();
+	/** Resolves once the Claude Code process has exited. */
+	readonly exited: Promise<void>;
+	private markExited!: () => void;
+
+	private readonly q: Query;
+	private readonly input = new AsyncQueue<SDKUserMessage>();
+	private readonly parked = new Map<string, { resolve: (r: CallToolResult) => void; reject: (e: Error) => void }>();
+	private readonly ready = new Map<string, CallToolResult>();
+	/** Last transcript-entry uuid streamed for each top-level API assistant message. */
+	private readonly assistantEntries = new Map<string, string>();
+	private readonly entryWaiters = new Map<string, Set<(uuid: string | undefined) => void>>();
+	private stderrTail = "";
+
+	constructor(spec: SessionSpec, chain: string, count: number, query: StartQuery) {
+		this.spec = spec;
+		this.model = spec.model;
+		this.systemPrompt = spec.systemPrompt;
+		this.chain = chain;
+		this.count = count;
+		this.sessionId = spec.resume?.sessionId ?? randomUUID();
+		this.exited = new Promise((r) => {
+			this.markExited = r;
+		});
+
+		const persist = spec.tools.length > 0;
+
+		this.q = query({
+			prompt: this.input,
+			options: {
+				cwd: spec.cwd,
+				model: spec.model,
+				systemPrompt: spec.systemPrompt,
+				tools: [],
+				mcpServers: spec.tools.length > 0 ? { [MCP_SERVER]: { type: "sdk", name: MCP_SERVER, instance: this.mcpServer(spec.tools) as never } } : {},
+				allowedTools: spec.tools.map((t) => MCP_PREFIX + t.name),
+				// Only pi's tools are allowed, and they wait for pi. Anything else Claude Code tries is denied.
+				permissionMode: "dontAsk",
+				settingSources: [],
+				strictMcpConfig: true,
+				includePartialMessages: true,
+				verbatimPrompts: true,
+				persistSession: persist,
+				title: "pi",
+				thinking: spec.thinking,
+				...(spec.effort ? { effort: spec.effort } : {}),
+				...(spec.resume ? { resume: spec.resume.sessionId, ...(spec.resume.at ? { resumeSessionAt: spec.resume.at } : {}) } : { sessionId: this.sessionId }),
+				...(spec.pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable: spec.pathToClaudeCodeExecutable } : {}),
+				env: childEnv(process.env, spec),
+				stderr: (d) => {
+					this.stderrTail = (this.stderrTail + d).slice(-2000);
+				},
+			},
+		});
+		void this.pump();
+	}
+
+	private mcpServer(tools: Tool[]): ToolServer {
+		return new ToolServer(MCP_SERVER, tools, async (id) => {
+			if (!id) return { content: [{ type: "text", text: "pi bridge: tool call without a tool_use id" }], isError: true };
+			const done = this.ready.get(id);
+			if (done) {
+				this.ready.delete(id);
+				return done;
+			}
+			return new Promise<CallToolResult>((resolve, reject) => this.parked.set(id, { resolve, reject }));
+		});
+	}
+
+	private async pump(): Promise<void> {
+		try {
+			for await (const m of this.q) {
+				const sdkMessage = m as any;
+				if (sdkMessage.type === "assistant" && !sdkMessage.parent_tool_use_id && sdkMessage.message?.id && sdkMessage.uuid) this.rememberEntry(sdkMessage.message.id, sdkMessage.uuid);
+				if (m.type === "user" && !m.parent_tool_use_id && Array.isArray(m.message.content)) {
+					// A tool_result Claude Code produced without asking pi (e.g. an unknown tool name).
+					for (const b of m.message.content as any[]) {
+						if (b.type === "tool_result" && !this.parkedOrDelivered(b.tool_use_id)) this.servedByClaude.add(b.tool_use_id);
+					}
+				}
+				this.events.push(m);
+			}
+		} catch (e) {
+			this.events.push({ type: "pi_error", error: errorText(e, this.stderrTail) } as any);
+		} finally {
+			this.dead = true;
+			for (const messageId of [...this.entryWaiters.keys()]) this.settleEntryWaiters(messageId, undefined);
+			this.events.close();
+			for (const p of this.parked.values()) p.reject(new Error("Claude Code session ended"));
+			this.parked.clear();
+			this.markExited();
+		}
+	}
+
+	private rememberEntry(messageId: string, uuid: string): void {
+		this.assistantEntries.set(messageId, uuid);
+		this.settleEntryWaiters(messageId, uuid);
+	}
+
+	private settleEntryWaiters(messageId: string, uuid: string | undefined): void {
+		const waiters = this.entryWaiters.get(messageId);
+		if (!waiters) return;
+		this.entryWaiters.delete(messageId);
+		for (const resolve of waiters) resolve(uuid);
+	}
+
+	async entryUuid(messageId: string): Promise<string | undefined> {
+		const known = this.assistantEntries.get(messageId);
+		if (known || this.dead) return known;
+		return new Promise((resolve) => {
+			const done = (uuid: string | undefined) => {
+				clearTimeout(timer);
+				resolve(uuid ?? this.assistantEntries.get(messageId));
+			};
+			const timer = setTimeout(() => this.settleEntryWaiters(messageId, undefined), 500);
+			timer.unref?.();
+			const waiters = this.entryWaiters.get(messageId) ?? new Set<(uuid: string | undefined) => void>();
+			waiters.add(done);
+			this.entryWaiters.set(messageId, waiters);
+		});
+	}
+
+	private delivered = new Set<string>();
+	private parkedOrDelivered(id: string): boolean {
+		return this.parked.has(id) || this.delivered.has(id) || this.ready.has(id);
+	}
+
+	/** Start a user turn (or continue after tool results when resuming). */
+	send(content: any[], priority?: "now" | "next" | "later"): void {
+		this.lastUsed = Date.now();
+		this.input.push({
+			type: "user",
+			message: { role: "user", content },
+			parent_tool_use_id: null,
+			...(priority ? { priority } : {}),
+		} as SDKUserMessage);
+	}
+
+	/** Answer a parked (or soon to be issued) MCP tool call with pi's result. */
+	deliver(result: ToolResultMessage): void {
+		const id = toolUseId(result.toolCallId);
+		this.awaiting.delete(id);
+		if (this.servedByClaude.has(id)) return;
+		this.delivered.add(id);
+		const r: CallToolResult = {
+			content: result.content.map((c) => (c.type === "text" ? { type: "text", text: c.text } : { type: "image", data: c.data, mimeType: c.mimeType })),
+			...(result.isError ? { isError: true } : {}),
+		};
+		if (r.content.length === 0) r.content.push({ type: "text", text: "(no output)" });
+		const p = this.parked.get(id);
+		if (p) {
+			this.parked.delete(id);
+			p.resolve(r);
+		} else this.ready.set(id, r);
+	}
+
+	async setModel(model: string): Promise<void> {
+		if (model === this.model) return;
+		await this.q.setModel(model);
+		this.model = model;
+	}
+
+	async interrupt(): Promise<void> {
+		try {
+			await this.q.interrupt();
+		} catch {}
+	}
+
+	close(): void {
+		if (this.dead) return;
+		this.dead = true;
+		this.input.close();
+		try {
+			this.q.close();
+		} catch {}
+	}
+
+	get stderr(): string {
+		return this.stderrTail;
+	}
+}
+
+export function errorText(e: unknown, stderr = ""): string {
+	const msg = e instanceof Error ? e.message : String(e);
+	return stderr.trim() ? `${msg}\n${stderr.trim().split("\n").slice(-5).join("\n")}` : msg;
+}

package/packages/subscription/src/util.ts

@@ -0,0 +1,73 @@
+import { createHash } from "node:crypto";
+
+/** Unbounded single-consumer async queue. `close()` ends iteration after buffered items drain. */
+export class AsyncQueue<T> implements AsyncIterable<T> {
+	private items: T[] = [];
+	private waiters: ((r: IteratorResult<T>) => void)[] = [];
+	private closed = false;
+
+	push(item: T): void {
+		if (this.closed) return;
+		const w = this.waiters.shift();
+		if (w) w({ value: item, done: false });
+		else this.items.push(item);
+	}
+
+	close(): void {
+		this.closed = true;
+		for (const w of this.waiters.splice(0)) w({ value: undefined as never, done: true });
+	}
+
+	/** Takes out the waiting items that match, and leaves the rest in order. */
+	take(matches: (item: T) => boolean): T[] {
+		const taken = this.items.filter(matches);
+		this.items = this.items.filter((item) => !matches(item));
+		return taken;
+	}
+
+	get isClosed(): boolean {
+		return this.closed;
+	}
+
+	/** Next item, or undefined once closed and drained. Rejects on abort. */
+	next(signal?: AbortSignal): Promise<T | undefined> {
+		if (this.items.length > 0) return Promise.resolve(this.items.shift());
+		if (this.closed) return Promise.resolve(undefined);
+		return new Promise((resolve, reject) => {
+			const onAbort = () => {
+				const i = this.waiters.indexOf(waiter);
+				if (i >= 0) this.waiters.splice(i, 1);
+				reject(new Error("aborted"));
+			};
+			const waiter = (r: IteratorResult<T>) => {
+				signal?.removeEventListener("abort", onAbort);
+				resolve(r.done ? undefined : r.value);
+			};
+			if (signal?.aborted) return reject(new Error("aborted"));
+			signal?.addEventListener("abort", onAbort, { once: true });
+			this.waiters.push(waiter);
+		});
+	}
+
+	async *[Symbol.asyncIterator](): AsyncIterator<T> {
+		for (;;) {
+			const item = await this.next();
+			if (item === undefined && this.closed && this.items.length === 0) return;
+			yield item as T;
+		}
+	}
+}
+
+/** JSON with sorted object keys, so equal values hash equally regardless of key order. */
+export function stableStringify(value: unknown): string {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	const keys = Object.keys(value as object)
+		.filter((k) => (value as Record<string, unknown>)[k] !== undefined)
+		.sort();
+	return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify((value as Record<string, unknown>)[k])}`).join(",")}}`;
+}
+
+export function sha(text: string): string {
+	return createHash("sha256").update(text).digest("hex").slice(0, 32);
+}

package/packages/web/README.md

@@ -9,19 +9,19 @@ A web page can hold instructions aimed at the AI reading it. So a separate model
 ## Install
 
 ```bash
-pi install npm:@huseynsnmz/pi-suite@0.2.2
+pi install npm:@huseynsnmz/pi-suite@0.2.4
 ```
 
 `web_fetch` works straight away. It reads pages with the session's model, unless you set `readerModel` or use [pi-router](https://github.com/huseynsnmz/pi-suite/tree/main/packages/router), which can choose the reader. `web_search` stays off until you choose where searches go.
 
 ## Search
 
-Everything you search for leaves your machine, so nothing is chosen for you. Settings go in `~/.pi/agent/web.json`, and are read when Pi starts, so restart it after editing the file.
+Everything you search for leaves your machine, so nothing is chosen for you. Settings go in `~/.pi/agent/the web settings`, and are read when Pi starts, so restart it after editing the file.
 
 **Your own SearXNG server** needs no account, but it does pass your searches on to the search engines it uses:
 
 ```json
-{ "searxngUrl": "http://localhost:8888" }
+{ "web": { "searxngUrl": "http://localhost:8888" } }
 ```
 
 SearXNG only answers in JSON if you list it under `search.formats` in its `settings.yml`. Public SearXNG servers almost always refuse this.
@@ -29,7 +29,7 @@ SearXNG only answers in JSON if you list it under `search.formats` in its `setti
 **markdown.new** is free and needs no key: 30 searches a minute and 500 a day for your IP, with a shared cap across everyone using it. Your searches go to its operator, then Serper and Google. This is behind a flag:
 
 ```json
-{ "companySearch": true }
+{ "web": { "companySearch": true } }
 ```
 
 ## Settings
@@ -49,7 +49,7 @@ SearXNG only answers in JSON if you list it under `search.formats` in its `setti
 | `strictUrls` | Set to `true` to be asked about every URL the agent wasn't given |
 | `askNewDomains` | Set to `true` to be asked before the first fetch from each site |
 
-`/web` shows what's in use, and `/web reader` lets you pick the page reader from your models. It saves to `web.json` and applies straight away. If `web.json` can't be read or has a wrong value, the web tools stay off and Pi says why.
+`/web` shows what's in use, and `/web reader` lets you pick the page reader from your models. It saves it and applies straight away. If the web settings can't be read or has a wrong value, the web tools stay off and Pi says why.
 
 ## What it checks
 

package/packages/web/src/config.ts

@@ -1,6 +1,5 @@
-/** Settings live in the agent folder only: a project's own file could point searches at its author's server. */
-import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+/** Settings live in the web section of ~/.pi/agent/suite.json only: a project's own file could point searches at its author's server. */
+import { readSection, writeSection } from "../../../src/settings.ts";
 import type { DnsFilter } from "./dnsfilter.ts";
 
 export type SearchProvider = { name: "searxng"; url: string } | { name: "markdown.new" };
@@ -33,24 +32,24 @@ const DNS_FILTERS: DnsFilter[] = ["cloudflare-family", "cloudflare-security", "o
 function strings(raw: Record<string, unknown>, key: string): string[] {
   const value = raw[key];
   if (value === undefined) return [];
-  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) throw new Error(`${key} in web.json must be a list of strings`);
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) throw new Error(`${key} in suite.json's web section must be a list of strings`);
   return value.map((item: string) => item.toLowerCase());
 }
 
 function flag(raw: Record<string, unknown>, key: string): boolean {
   const value = raw[key];
   if (value === undefined) return false;
-  if (typeof value !== "boolean") throw new Error(`${key} in web.json must be true or false`);
+  if (typeof value !== "boolean") throw new Error(`${key} in suite.json's web section must be true or false`);
   return value;
 }
 
 export function parseConfig(raw: Record<string, unknown>): WebConfig {
   const companySearch = flag(raw, "companySearch");
-  if (raw.provider !== undefined && typeof raw.provider !== "string") throw new Error("provider in web.json must be a name");
+  if (raw.provider !== undefined && typeof raw.provider !== "string") throw new Error("provider in suite.json's web section must be a name");
   const wanted = typeof raw.provider === "string" ? raw.provider : companySearch ? "markdown.new" : "searxng";
-  if (raw.searxngUrl !== undefined && (typeof raw.searxngUrl !== "string" || !/^https?:\/\//.test(raw.searxngUrl))) throw new Error("searxngUrl in web.json must be an http or https URL");
-  if (raw.dnsFilter !== undefined && !DNS_FILTERS.includes(raw.dnsFilter as DnsFilter)) throw new Error(`dnsFilter in web.json must be one of ${DNS_FILTERS.join(", ")}`);
-  if (raw.readerModel !== undefined && (typeof raw.readerModel !== "string" || !raw.readerModel.includes("/"))) throw new Error("readerModel in web.json must be written provider/id");
+  if (raw.searxngUrl !== undefined && (typeof raw.searxngUrl !== "string" || !/^https?:\/\//.test(raw.searxngUrl))) throw new Error("searxngUrl in suite.json's web section must be an http or https URL");
+  if (raw.dnsFilter !== undefined && !DNS_FILTERS.includes(raw.dnsFilter as DnsFilter)) throw new Error(`dnsFilter in suite.json's web section must be one of ${DNS_FILTERS.join(", ")}`);
+  if (raw.readerModel !== undefined && (typeof raw.readerModel !== "string" || !raw.readerModel.includes("/"))) throw new Error("readerModel in suite.json's web section must be written provider/id");
   const url = typeof raw.searxngUrl === "string" ? raw.searxngUrl.replace(/\/+$/, "") : null;
 
   let searchProvider: SearchProvider | null = null;
@@ -66,7 +65,7 @@ export function parseConfig(raw: Record<string, unknown>): WebConfig {
   }
 
   const minConfidence = raw.minConfidence ?? 4;
-  if (typeof minConfidence !== "number" || !Number.isInteger(minConfidence) || minConfidence < 1 || minConfidence > 10) throw new Error("minConfidence in web.json must be a whole number from 1 to 10");
+  if (typeof minConfidence !== "number" || !Number.isInteger(minConfidence) || minConfidence < 1 || minConfidence > 10) throw new Error("minConfidence in suite.json's web section must be a whole number from 1 to 10");
 
   const [provider, ...id] = typeof raw.readerModel === "string" ? raw.readerModel.split("/") : [];
   return {
@@ -86,24 +85,15 @@ export function parseConfig(raw: Record<string, unknown>): WebConfig {
 }
 
 export function loadConfig(agentDir: string): WebConfig {
-  const path = join(agentDir, "web.json");
-  if (!existsSync(path)) return parseConfig({});
-  const raw: unknown = JSON.parse(readFileSync(path, "utf8"));
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`${path} must hold a JSON object`);
-  return parseConfig(raw as Record<string, unknown>);
+  return parseConfig(readSection(agentDir, "web"));
 }
 
-/** Changes only the reader in the file, so a setting this doesn't know about survives. A rename keeps a crash from leaving half a file. */
+/** Changes only the reader, so a setting this doesn't know about survives. */
 export function saveReaderModel(agentDir: string, model: string | null): WebConfig {
-  const path = join(agentDir, "web.json");
-  const raw: unknown = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : {};
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`${path} must hold a JSON object`);
-  const next = { ...(raw as Record<string, unknown>) };
+  const next = { ...readSection(agentDir, "web") };
   if (model === null) delete next.readerModel;
   else next.readerModel = model;
   const config = parseConfig(next);
-  const temp = `${path}.${process.pid}.tmp`;
-  writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`);
-  renameSync(temp, path);
+  writeSection(agentDir, "web", next);
   return config;
 }

package/packages/web/src/index.ts

@@ -6,7 +6,7 @@ import { blockedLinks, checkSite } from "./dnsfilter.ts";
 import { toText } from "./extract.ts";
 import { isIP } from "node:net";
 import { fetchPublic } from "./net.ts";
-import { askReader, READ_CHARS } from "./reader.ts";
+import { askReader, READ_CHARS, type RoutedReader } from "./reader.ts";
 import { linkIsClean, looksLikeInstructions, urlsIn } from "./sanitize.ts";
 import { search } from "./search.ts";
 import { checkQuery, checkQuestion, checkUrl, givenSites, onSite, urlConcern, wasOffered } from "./validate.ts";
@@ -79,7 +79,7 @@ export default function piWeb(pi: ExtensionAPI): void {
     const known = [...givenSites(entries), ...config.trustedDomains, ...config.allowDomains, ...approvedSites].some((site) => onSite(host, site));
     const written = writtenOnSite.get(host) ?? 0;
     if (!known || written >= MAX_WRITTEN_PER_SITE) {
-      if (!ctx.hasUI) throw new Error(`The agent wrote this address itself, on a site nobody has named or approved, and there's nobody here to approve it. Add ${host} to trustedDomains in web.json, or use a link you were given`);
+      if (!ctx.hasUI) throw new Error(`The agent wrote this address itself, on a site nobody has named or approved, and there's nobody here to approve it. Add ${host} to trustedDomains in /suite, or use a link you were given`);
       const why = known ? `The agent has written ${written} addresses of its own on this site.` : "The agent found this site itself. Allowing it lets the agent fetch from it for the rest of this session.";
       if (!(await ctx.ui.confirm("Fetch from this site?", `${host}\n\n${url.href}\n\n${why}`))) throw new Error(`The user declined fetching from ${host}`);
       approvedSites.add(host);
@@ -145,7 +145,7 @@ export default function piWeb(pi: ExtensionAPI): void {
       const key = `${url.href}\n${offset}\n${question}`;
       const known = answers.get(key);
       const fresh = known && Date.now() - known.at < CACHE_MS;
-      const answer = fresh ? known.text : await withoutBlockedLinks(await askReader(ctx, config, question, part, signal, routerReader(ctx)), signal);
+      const answer = fresh ? known.text : await withoutBlockedLinks(await askReader(ctx, config, question, part, signal, routerProbe(ctx)), signal);
       if (!fresh) remember(answers, key, answer);
       const left = page.text.length - offset - part.length;
       return reply(`From ${url.hostname}, not checked against anything else:\n${answer}${looksLikeInstructions(part) ? WARNING : ""}${left > 0 ? `\n\n${left} characters unread. Fetch again with offset ${offset + part.length} for more.` : ""}`, [...urlsIn(answer), ...pageLinks(part)]);
@@ -172,7 +172,7 @@ export default function piWeb(pi: ExtensionAPI): void {
         const links = clean.filter((link) => !blocked.has(link));
         if (!links.length) return reply(clean.length ? "Every result was on a site blocked by the site filter." : "No results.");
         const part = results.text.slice(0, SEARCH_CHARS);
-        const answer = await withoutBlockedLinks(await askReader(ctx, config, question, part, signal, routerReader(ctx)), signal);
+        const answer = await withoutBlockedLinks(await askReader(ctx, config, question, part, signal, routerProbe(ctx)), signal);
         return reply(`${answer}${looksLikeInstructions(part) ? WARNING : ""}\n\nLinks:\n${links.map((link) => `- ${link}`).join("\n")}`, [...links, ...urlsIn(answer), ...pageLinks(part)], [...new Set(links.map((link) => new URL(link).hostname))]);
       },
     });
@@ -181,12 +181,16 @@ export default function piWeb(pi: ExtensionAPI): void {
   const SESSION_MODEL = "The session's model";
 
   /** Whoever answers fills in the object, so it doesn't matter which loads first. */
-  function routerReader(ctx: ExtensionContext): string | undefined {
+  function routerProbe(ctx: ExtensionContext): RoutedReader | undefined {
     // Only while it's selected: a page must not go to a provider this session didn't choose.
     if (ctx.model?.api !== "pi-virtual") return undefined;
-    const probe: { model?: string } = {};
+    const probe: { model?: string; thinking?: RoutedReader["thinking"] } = {};
     pi.events.emit("pi-router:reader-model", probe);
-    return probe.model;
+    return probe.model === undefined ? undefined : { model: probe.model, thinking: probe.thinking };
+  }
+
+  function routerReader(ctx: ExtensionContext): string | undefined {
+    return routerProbe(ctx)?.model;
   }
 
   async function pickReader(ctx: ExtensionContext): Promise<void> {

package/packages/web/src/reader.ts

@@ -1,4 +1,5 @@
 /** The separate model that reads web text. It has no tools, so the most a page can do to it is spoil its answer. */
+import type { ThinkingLevel } from "@earendil-works/pi-ai";
 import { randomBytes } from "node:crypto";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { WebConfig } from "./config.ts";
@@ -50,11 +51,19 @@ function readerModel(ctx: ExtensionContext, config: WebConfig, routed: string |
   return ctx.modelRegistry.find(routed.slice(0, at), routed.slice(at + 1));
 }
 
-export async function askReader(ctx: ExtensionContext, config: WebConfig, question: string, text: string, signal?: AbortSignal, routed?: string): Promise<string> {
-  const model = readerModel(ctx, config, routed);
-  if (!model) throw new Error("No model to read the page with, so it wasn't read. Set readerModel in web.json");
+export interface RoutedReader {
+  model: string;
+  thinking?: ThinkingLevel | "off";
+}
+
+export async function askReader(ctx: ExtensionContext, config: WebConfig, question: string, text: string, signal?: AbortSignal, routed?: RoutedReader): Promise<string> {
+  const model = readerModel(ctx, config, routed?.model);
+  if (!model) throw new Error("No model to read the page with, so it wasn't read. Set readerModel in /suite");
   const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
   if (!auth.ok) throw new Error(`No key for the page reader ${model.provider}/${model.id}`);
+  // Only for the model the router chose, as suite.json's own reader has no level to go by.
+  const level = routed?.model === `${model.provider}/${model.id}` ? routed.thinking : undefined;
+  const reasoning = level === "off" ? undefined : level;
   // Through the registry, because the session's model can be a virtual one.
   const response = await ctx.modelRegistry.streamSimple(
     model,
@@ -62,12 +71,14 @@ export async function askReader(ctx: ExtensionContext, config: WebConfig, questi
       systemPrompt: SYSTEM,
       messages: [{ role: "user", content: [{ type: "text", text: readerPrompt(question, text) }], timestamp: Date.now() }],
     },
-    { signal, maxTokens: 2000, cacheRetention: "none" },
+    // Reasoning uses the same tokens as the answer, and could leave none for it.
+    { signal, maxTokens: reasoning === undefined ? 2000 : 16000, cacheRetention: "none", ...(reasoning === undefined ? {} : { reasoning }) },
   ).result();
   if (response.stopReason === "error" || response.stopReason === "aborted") {
     // Not the provider's message, as some repeat part of the request, and that's page text.
     throw new Error(`The page reader failed (${response.stopReason}), so the page wasn't read`);
   }
   const raw = response.content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n");
+  if (raw.trim() === "") throw new Error("The page reader gave no answer, so the page wasn't read");
   return checkAnswer(raw, text, config.minConfidence);
 }

package/packages/web/src/validate.ts

@@ -29,7 +29,7 @@ export function checkQuery(query: string, privateWords: string[] = []): string {
   if (LOCAL_PATH.test(out)) throw new Error("This query holds a path on this machine, and it would leave this machine");
   if (EMAIL.test(out)) throw new Error("This query holds an email address, and it would leave this machine");
   const lower = out.toLowerCase();
-  if (privateWords.some((word) => word && lower.includes(word))) throw new Error("This query holds a word set as private in web.json, and it would leave this machine");
+  if (privateWords.some((word) => word && lower.includes(word))) throw new Error("This query holds a word set as private in /suite, and it would leave this machine");
   return out;
 }
 
@@ -157,7 +157,7 @@ export function urlConcern(url: URL, privateWords: string[] = []): string | null
   const lowerPath = path.toLowerCase();
   if (new RegExp(LOCAL_PATH.source, "i").test(path) || EMAIL.test(path)) return "holds a local path or email address";
   const lower = `${url.hostname}${lowerPath}`;
-  if (privateWords.some((word) => word && lower.includes(word))) return "holds a word set as private in web.json";
+  if (privateWords.some((word) => word && lower.includes(word))) return "holds a word set as private in /suite";
   return null;
 }