gentle-pi 4.0.0 → 4.2.0

package/lib/model-price-ratio.ts

@@ -0,0 +1,83 @@
+// gentle-shell#1731: the orchestrator/worker price ratio is a runtime fact.
+// The harness renders it as one line computed from catalog prices, so the
+// model routes implementation by a number it never has to estimate.
+
+export interface ModelIdentity {
+	provider: string | undefined;
+	id: string;
+}
+
+/** Catalog price in USD per 1M tokens, as Pi's model registry reports it. */
+export interface ModelCost {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+}
+
+export type ModelPriceLookup = (model: ModelIdentity) => ModelCost | undefined;
+
+export type ModelPriceRatio =
+	| { kind: "known"; orchestrator: string; worker: string; input: number; output: number; blended: number }
+	| { kind: "unknown"; reason: string };
+
+function label(model: ModelIdentity): string {
+	return model.provider ? `${model.provider}/${model.id}` : model.id;
+}
+
+function validPrice(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+export function computeModelPriceRatio(
+	orchestrator: ModelIdentity | undefined,
+	worker: ModelIdentity | undefined,
+	lookup: ModelPriceLookup,
+): ModelPriceRatio {
+	if (!orchestrator) return { kind: "unknown", reason: "orchestrator model unknown" };
+	if (!worker) return { kind: "unknown", reason: "worker model unknown" };
+	const prices: ModelCost[] = [];
+	for (const model of [orchestrator, worker]) {
+		let cost: ModelCost | undefined;
+		try {
+			cost = lookup(model);
+		} catch {
+			return { kind: "unknown", reason: "price lookup failed" };
+		}
+		if (!cost) return { kind: "unknown", reason: `no catalog price for ${label(model)}` };
+		if (!validPrice(cost.input) || !validPrice(cost.output)) return { kind: "unknown", reason: `zero or invalid price for ${label(model)}` };
+		prices.push(cost);
+	}
+	const [orchestratorCost, workerCost] = prices;
+	const input = orchestratorCost.input / workerCost.input;
+	const output = orchestratorCost.output / workerCost.output;
+	// The blended ratio is the larger of the two. Catalogs usually keep input
+	// and output prices proportional, so both agree; when they diverge, the
+	// session's token mix is unknown up front, and the dimension where the
+	// orchestrator is relatively pricier is the one delegation saves on.
+	return { kind: "known", orchestrator: label(orchestrator), worker: label(worker), input, output, blended: Math.max(input, output) };
+}
+
+// Rounds half up at one decimal; toFixed alone misrounds values
+// such as 2.95 because of their binary representation.
+function times(value: number): string {
+	return `${(Math.round(value * 10) / 10).toFixed(1)}x`;
+}
+
+export function renderModelRoutingLine(ratio: ModelPriceRatio): string {
+	if (ratio.kind === "unknown") return `Model routing: price ratio unknown (${ratio.reason}).`;
+	return `Model routing: orchestrator ${ratio.orchestrator} costs ${times(ratio.blended)} the worker ${ratio.worker} (input ${times(ratio.input)}, output ${times(ratio.output)}).`;
+}
+
+/** The harness fact line. Never throws: any failure renders the unknown line. */
+export function modelRoutingLine(
+	orchestrator: ModelIdentity | undefined,
+	worker: ModelIdentity | undefined,
+	lookup: ModelPriceLookup,
+): string {
+	try {
+		return renderModelRoutingLine(computeModelPriceRatio(orchestrator, worker, lookup));
+	} catch {
+		return renderModelRoutingLine({ kind: "unknown", reason: "price ratio failed" });
+	}
+}

package/lib/model-routing-authority.ts

@@ -28,6 +28,11 @@ export type ModelConfigFileResult =
 export const SAFE_MODEL_ID_PATTERN = /^[A-Za-z0-9._~:@/+%-]+$/;
 const SAFE_AGENT_NAME_PATTERN = /^[A-Za-z0-9._:@/+%-]+$/;
 
+/** Shared agent-name policy; the same test normalizeModelConfig applies per key. */
+export function isSafeAgentName(name: string): boolean {
+	return SAFE_AGENT_NAME_PATTERN.test(name);
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -78,7 +83,7 @@ export function normalizeModelConfig(value: unknown): AgentModelConfig | undefin
 	if (!isRecord(value)) return undefined;
 	const cleaned: AgentModelConfig = {};
 	for (const [name, entryValue] of Object.entries(value)) {
-		if (!SAFE_AGENT_NAME_PATTERN.test(name)) continue;
+		if (!isSafeAgentName(name)) continue;
 		const entry = normalizeRoutingEntry(entryValue);
 		if (entry) cleaned[name] = entry;
 	}

package/lib/nan-provider.ts

@@ -22,39 +22,61 @@ const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 // Reasoning shares max_tokens with the answer: 65,536 leaves answer room after a
 // 32,768 reasoning budget; DeepSeek uses NaN's 16,384 floor. Qwen 3.8 retains its
 // published 131K output maximum. The remaining 32,768 caps are configured, not NaN-published limits.
-// Pi requires explicit max mappings to offer that level; missing ordinary levels pass through.
-const FIXED_THINKING_LEVEL_MAP: NanChatModelConfig["thinkingLevelMap"] = {
-	off: null, minimal: null, low: null, high: null, xhigh: null, max: null,
-}; // Only medium remains usable: depth is fixed and reasoning cannot be disabled.
+// Pi requires explicit max mappings to offer that level; a null hides a level Pi would otherwise
+// offer, and missing ordinary levels pass through. Each map exposes exactly the efforts NaN's
+// reasoning contract declares and sends only values NaN accepts.
+// GLM 5.3 / GLM 5.3 Flash: low · medium · high · max, fully controllable and without an off.
+const GLM_THINKING_LEVEL_MAP: NanChatModelConfig["thinkingLevelMap"] = {
+	off: null, minimal: null, xhigh: null, max: "max",
+};
+// Qwen 3.6 and Gemma 4 honor none · minimal · low · medium · high · max as depth controls.
+// DeepSeek V4 Flash, Qwen 3.8 Flash, and MiMo accept the same values while NaN manages their
+// depth itself; none disables reasoning only where NaN honors it.
+const EXTENDED_THINKING_LEVEL_MAP: NanChatModelConfig["thinkingLevelMap"] = {
+	off: "none", xhigh: null, max: "max",
+};
+
+/**
+ * NaN accepts `reasoning_effort` for these models but manages their depth itself, so the selected
+ * level never changes it. Qwen 3.6 and Gemma 4 share the extended map yet honor the level as a
+ * reasoning budget, so the distinction lives here and the shell labels only these three automatic.
+ */
+export const NAN_ADAPTIVE_REASONING_MODEL_IDS: ReadonlySet<string> = new Set([
+	"deepseek-v4-flash", "qwen3.8-flash", "mimo-v2.6-flash",
+]);
+
+export function isNanAdaptiveReasoningModel(model: { provider: string; id: string } | undefined): boolean {
+	return model !== undefined && model.provider === NAN_PROVIDER_ID && NAN_ADAPTIVE_REASONING_MODEL_IDS.has(model.id);
+}
 
 const CHAT_MODELS: NanChatModelConfig[] = ([
 	{
 		id: "glm5.3", name: "GLM 5.3", input: ["text", "image"], contextWindow: 1_000_000,
-		thinkingLevelMap: { off: null, minimal: "low", xhigh: "max", max: "max" },
+		thinkingLevelMap: GLM_THINKING_LEVEL_MAP,
 	},
 	{
 		id: "deepseek-v4-flash", name: "DeepSeek V4 Flash", input: ["text", "image"], contextWindow: 1_000_000,
-		thinkingLevelMap: FIXED_THINKING_LEVEL_MAP, maxTokens: 16_384,
+		thinkingLevelMap: EXTENDED_THINKING_LEVEL_MAP, maxTokens: 16_384,
 	},
 	{
 		id: "glm5.3-flash", name: "GLM 5.3 Flash", input: ["text", "image"], contextWindow: 1_000_000,
-		thinkingLevelMap: { off: null, minimal: "low", xhigh: "max", max: "max" },
+		thinkingLevelMap: GLM_THINKING_LEVEL_MAP,
 	},
 	{
 		id: "qwen3.8-flash", name: "Qwen 3.8 Flash", input: ["text", "image"], contextWindow: 1_048_576,
-		thinkingLevelMap: FIXED_THINKING_LEVEL_MAP, maxTokens: 131_000,
+		thinkingLevelMap: EXTENDED_THINKING_LEVEL_MAP, maxTokens: 131_000,
 	},
 	{
 		id: "mimo-v2.6-flash", name: "MiMo V2.6 Flash", input: ["text", "image"], contextWindow: 1_000_000,
-		thinkingLevelMap: FIXED_THINKING_LEVEL_MAP,
+		thinkingLevelMap: EXTENDED_THINKING_LEVEL_MAP,
 	},
 	{
 		id: "gemma4", name: "Gemma 4", input: ["text", "image"], contextWindow: 262_000,
-		thinkingLevelMap: { off: "none", xhigh: "max", max: "max" }, maxTokens: 65_536,
+		thinkingLevelMap: EXTENDED_THINKING_LEVEL_MAP, maxTokens: 65_536,
 	},
 	{
 		id: "qwen3.6", name: "Qwen 3.6", input: ["text", "image"], contextWindow: 262_000,
-		thinkingLevelMap: { off: "none", xhigh: "max", max: "max" }, maxTokens: 65_536,
+		thinkingLevelMap: EXTENDED_THINKING_LEVEL_MAP, maxTokens: 65_536,
 	},
 ] satisfies Partial<NanChatModelConfig>[]).map((model) => ({
 	...model,