Swap the server engine to pi-ai/pi-agent-core (Band B+C of docs/pi-engine-swap.md)

The Vercel AI SDK survives only as Band D (useChat client + UIMessage
record types); @openrouter/ai-sdk-provider is uninstalled.

- src/agent/models.ts: PiEngine {model, streamFn} via createModels +
  openrouterProvider subpath; thinkingLevelFor maps config effort none->off
- src/agent/lh-tool.ts: neutral LhTool (zod authoring, optional execute,
  clientQuestion flag); toPiTool converts via z.toJSONSchema and re-runs
  zod inside execute so refinements ride the error-result retry path
- src/server/pi/record-adapter.ts: UIMessage records -> pi Messages
  (dangling tool calls get synthesized interrupted results)
- src/server/pi/ui-stream.ts: SSE bridge emitting AI-SDK-shaped chunks so
  the useChat client parses unchanged (continuation id rule, question
  tools never emit output, tool-input-error for bad authoring)
- teacher-agent.ts: stateless per-turn pi Agents; shouldStopAfterTurn
  stops only when every question-tool call resolved cleanly (errors retry)
- chat-handler.ts: buildAgent(outgoing) factory seam (stateless doctrine);
  assertValidUiMessages owns the retired SDK validation gate
- sub-agents via shared runSubagent (pi-run.ts); extraction stages stop
  after a clean submit; visual-maker keeps its hand-rolled loop over
  direct streamSimple calls; aborted model calls bill no usage
- tests: all model seams ported to pi-ai faux provider (scripted
  FauxResponseSteps, agent factories); handleChatRequest second param
  is now an agent factory

Gates: tsc, lint, build, 305/305. Live GLM smoke (disposable driver,
deleted): prober streaming + persistence, question seam, turn-2
continuation same message id, per-turn real token usage - ALL PASS.
Data wiped at the pivot (chats/graph/jobs, .gitkeeps kept).

src/agent/models.ts

@@ -1,17 +1,73 @@
-import { openrouter } from "@openrouter/ai-sdk-provider";
-import type { LanguageModel } from "ai";
+import {
+	createModels,
+	type Api,
+	type Model,
+	type Models,
+	type StreamFunction,
+} from "@earendil-works/pi-ai";
+import { openrouterProvider } from "@earendil-works/pi-ai/providers/openrouter";
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { MODELS, type ModelRole } from "../../config.ts";
 
 /**
- * The one factory every agent's model comes from. Model choice and thinking
- * budget live in config.ts (MODELS) — the single tuning table; this module
- * only wires them to OpenRouter. `effort: "none"` is OpenRouter's off-switch
- * for reasoning tokens; higher levels let the model think longer (and bill
- * accordingly).
+ * The one engine factory every agent's model comes from (the pi-ai swap,
+ * docs/pi-engine-swap.md). Model choice and thinking budget live in
+ * config.ts (MODELS) — the single tuning table; this module only wires them
+ * to pi-ai's OpenRouter provider.
+ *
+ * An "engine" is the model + the stream function the agent loop runs on —
+ * the two things a test fake replaces. Production engines resolve the model
+ * from pi-ai's static catalog (glm-5.3-flash and qwen3.8-max are both in
+ * 0.85.1's built-ins — no overlay fetch) and stream through the same Models
+ * collection.
  */
-export function modelFor(role: ModelRole): LanguageModel {
-	const spec = MODELS[role];
-	return openrouter(spec.model, {
-		reasoning: { enabled: true, effort: spec.effort },
-	});
+
+export interface PiEngine {
+	model: Model<Api>;
+	streamFn: StreamFunction;
 }
+
+export type { ThinkingLevel };
+
+/** config's effort scale maps 1:1 onto pi's thinking levels (none→off). */
+export function thinkingLevelFor(role: ModelRole): ThinkingLevel {
+	const effort = MODELS[role].effort as string;
+	return effort === "none" ? "off" : (effort as ThinkingLevel);
+}
+
+let collection: ReturnType<typeof createModels> | undefined;
+
+/** The process-wide pi-ai Models collection (OpenRouter catalog). */
+export function piModels() {
+	if (!collection) {
+		collection = createModels();
+		collection.setProvider(openrouterProvider());
+	}
+	return collection;
+}
+
+/** OpenRouter API key (BYOK); tests never read this — they inject engines. */
+export function openRouterApiKey(): string | undefined {
+	return process.env.OPENROUTER_API_KEY || undefined;
+}
+
+/** The production engine for one agent role (config.ts MODELS). */
+export function piEngineFor(role: ModelRole): PiEngine {
+	const models: Models = piModels();
+	const spec = MODELS[role];
+	const model = models.getModel("openrouter", spec.model);
+	if (!model) throw new Error(`OpenRouter catalog has no model ${spec.model} (role ${role})`);
+	const level = thinkingLevelFor(role);
+	return {
+		model,
+		// bound streamSimple: the agent loop forwards state.thinkingLevel as
+		// `reasoning` (undefined = off on pi-ai's scale); pin the role's level
+		// so a bare engine can never drift.
+		streamFn: (requestModel, context, options) =>
+			models.streamSimple(requestModel, context, {
+				...options,
+				reasoning: level === "off" ? undefined : level,
+				apiKey: options?.apiKey ?? openRouterApiKey(),
+			}),
+	};
+}