pi-quiver 5.2.1 → 5.2.3

package/CHANGELOG.md

@@ -8,6 +8,18 @@ Published to npm as `pi-quiver` (`pi install npm:pi-quiver`). Pushing a
 via OIDC trusted publishing. The release helper at
 `.agents/skills/release/scripts/release.sh` cuts the tag; CI publishes.
 
+## v5.2.3 - 2026-09-04
+
+- `fast-mode`: fix `400 fallbacks: Extra inputs are not permitted` on OAuth/subscription auth with fallback-capable models (`claude-opus-5` on pi 0.84.x). The 5.2.2 beta probe imported `@earendil-works/pi-ai/api/anthropic-messages.lazy`, which pi's extension loader does not alias for installed packages, so it always failed in real installs and the static beta list dropped `server-side-fallback-2026-07-01` while pi kept `fallbacks` in the body. Probe now imports the aliased `@earendil-works/pi-ai/compat`; the static fallback also adds the fallback beta whenever `model.compat.allowedFallbackModels` is non-empty.
+
+## v5.2.2 - 2026-09-03
+
+- fast-mode: discover pi's `anthropic-beta` list at request time by probing
+  pi-ai's request assembly (capturing fetch, zero network) instead of
+  rebuilding it from a fixed list - fixes 400 "fallbacks: Extra inputs are
+  not permitted" on `claude-opus-5` (#11). Probe failure degrades to the
+  previous static header.
+
 ## v5.2.1 - 2026-09-02
 
 - sword-header: clip each header line to the terminal width in `render(width)` (ANSI-aware `truncateToWidth`, hard clip). Fixes a hard crash (`Rendered line N exceeds terminal width`) in terminals/panes narrower than 80 columns.

package/README.md

@@ -184,7 +184,7 @@ survive untouched.
 
 `herdrTab` (default `true`) mirrors the same curated label to the Herdr tab bar over Herdr's unix socket, independent of `ghosttyTab` - either sink can be toggled off without affecting the other. It's claim-once: the extension adopts a tab only while it still shows its default numeric label (its live 1-based position among the workspace's tabs); a manually renamed tab, or one renamed mid-session by hand, is never touched again for that session - the human's label always wins. On every shutdown (quit, reload, `/new`, resume, fork) a claimed tab's label is restored to its then-current default position, so a successor session in the same pane can claim cleanly. It only ever runs in TUI mode, on an attached TTY, under Herdr (`HERDR_ENV`/`HERDR_TAB_ID`/`HERDR_SOCKET_PATH` all set) - `pi -p`/json/rpc runs and background subagents never touch the tab. Caveats: a hard crash (`kill -9`) skips the restore and leaves the stale label - rename the tab by hand to recover; and the restored label is internally a custom name (Herdr has no clear-to-auto API), so that tab keeps a number-looking label but stops renumbering on later tab closes/reorders.
 
-`fastMode` only affects `claude-opus-4-8` and `claude-opus-5` requests on Anthropic's `anthropic-messages` API; enabling it opts into premium fast-mode pricing. `--fast` forces it on for one launch; `/fast on|off` toggles live. Proxy providers (opencode, cloudflare-ai-gateway) are excluded. `fastMode`'s header injection needs the `before_provider_headers` hook (pi bundling `@earendil-works/pi-coding-agent` >= 0.80.5); on older pi the beta header is silently not sent. See [doc/fetch.md](doc/fetch.md) and [doc/doc-to-md.md](doc/doc-to-md.md) for the ingestion tools' full reference; session-name/sword-header behavior above is complete.
+`fastMode` only affects `claude-opus-4-8` and `claude-opus-5` requests on Anthropic's `anthropic-messages` API; enabling it opts into premium fast-mode pricing. `--fast` forces it on for one launch; `/fast on|off` toggles live. Proxy providers (opencode, cloudflare-ai-gateway) are excluded. `fastMode`'s header injection needs the `before_provider_headers` hook (pi bundling `@earendil-works/pi-coding-agent` >= 0.80.5); on older pi the beta header is silently not sent. The `anthropic-beta` header is discovered at request time by probing pi's own request assembly (no network), so conditional betas pi adds - e.g. `server-side-fallback-2026-07-01` for models with server-side fallback - are preserved alongside `fast-mode-2026-02-01`. If the probe fails, the header falls back to the static OAuth-identity + fast-mode list. See [doc/fetch.md](doc/fetch.md) and [doc/doc-to-md.md](doc/doc-to-md.md) for the ingestion tools' full reference; session-name/sword-header behavior above is complete.
 
 `pi-ai` prices every fast request at standard rates - it has no `usage.speed` support and no request-level pricing modifier - so `fastMode` corrects the reported cost itself: a `message_end` handler scales all four `usage.cost` components by `FAST_MODE_COST_MULTIPLIER` (2x) and returns the corrected message. Persisted session JSONL and pi's own native cost display are always exact, since they're written from this corrected message. pi-cohort's live `Σ$` reflects the correction only when pi-quiver's `message_end` handler runs before pi-cohort's - best-effort, depending on extension load order - and is reconciled on pi-cohort's next `session_start` regardless. The upstream fix (teaching `pi-ai`'s `Usage`/`calculateCost` about `usage.speed`) is the better long-term path and is tracked separately.
 

package/extensions/fast-mode.ts

@@ -13,16 +13,22 @@
  *
  * Header coupling to pi-ai internals: pi assembles `anthropic-beta` AFTER this
  * hook and merges the hook's headers LAST, so setting the header here REPLACES
- * pi's list. For opus-4-8 and opus-5 pi's conditional betas (fine-grained tool
- * streaming, interleaved thinking) are never applied (eager tool streaming
- * defaults on + forceAdaptiveThinking; verified identical compat in pi-ai
- * 0.82.1), so the only betas to preserve are the OAuth identity betas. We
- * detect OAuth via the same token marker pi uses and rebuild the exact list.
- * If pi later adds betas for these models, revisit buildBetaHeader.
+ * pi's list. Instead of guessing that list, the hook discovers it: it probes
+ * pi-ai's own request assembly (dynamic import of `@earendil-works/pi-ai/compat`,
+ * one of the four specifiers pi's extension loader aliases for installed
+ * packages - deeper subpaths like `/api/*.lazy` do NOT resolve there) with a
+ * capturing fetch - zero network, zero tokens - and unions
+ * the captured betas with the fast-mode beta. Probe failure falls back to the
+ * static reconstruction (OAUTH_IDENTITY_BETAS stays, demoted to fallback-only
+ * seeding). Known limit: the probe context is tool-less, so tool/thinking-
+ * conditional betas are captured under fixed defaults - fine while allowlisted
+ * models keep forceAdaptiveThinking: true in the catalog. Probe cost: one
+ * extra in-process request-assembly pass per qualifying call, no network -
+ * per-request by design, no cache.
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { Usage } from "@earendil-works/pi-ai";
+import type { Context, Model, StreamOptions, Usage } from "@earendil-works/pi-ai";
 import { resolveConfig } from "../lib/extension-config.ts";
 
 export const FAST_MODE_BETA = "fast-mode-2026-02-01";
@@ -46,6 +52,15 @@ export function scaleCost(cost: Usage["cost"], multiplier: number): Usage["cost"
 }
 
 export const OAUTH_IDENTITY_BETAS = ["claude-code-20250219", "oauth-2025-04-20"];
+// Mirrors pi-ai's SERVER_SIDE_FALLBACK_BETA: pi puts `fallbacks` in the body
+// whenever model.compat.allowedFallbackModels is non-empty, and OAuth rejects
+// that body without the beta (400 "fallbacks: Extra inputs are not permitted").
+export const SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+
+export function needsFallbackBeta(model: Model<any> | undefined): boolean {
+	const compat = model?.compat as { allowedFallbackModels?: unknown[] } | undefined;
+	return (compat?.allowedFallbackModels?.length ?? 0) > 0;
+}
 const STATUS_KEY = "fast-mode";
 const BETA_HEADER = "anthropic-beta";
 
@@ -82,7 +97,12 @@ export function injectSpeed(payload: unknown): unknown {
 	return { ...(payload as Record<string, unknown>), speed: FAST_SPEED };
 }
 
-export function buildBetaHeader(existing: string | null | undefined, isOAuth: boolean): string {
+export function buildBetaHeader(
+	existing: string | null | undefined,
+	isOAuth: boolean,
+	probedBetas: string | null = null,
+	fallbackBeta = false,
+): string {
 	const seen = new Set<string>();
 	const out: string[] = [];
 	const add = (b: string): void => {
@@ -92,12 +112,65 @@ export function buildBetaHeader(existing: string | null | undefined, isOAuth: bo
 			out.push(t);
 		}
 	};
-	if (isOAuth) OAUTH_IDENTITY_BETAS.forEach(add);
+	if (probedBetas !== null) probedBetas.split(",").forEach(add);
+	else {
+		if (isOAuth) OAUTH_IDENTITY_BETAS.forEach(add);
+		if (fallbackBeta) add(SERVER_SIDE_FALLBACK_BETA);
+	}
 	if (typeof existing === "string") existing.split(",").forEach(add);
 	add(FAST_MODE_BETA);
 	return out.join(",");
 }
 
+export type ProbeAuth = { apiKey?: string; headers?: Record<string, string | null> };
+
+// Minimal context for the beta probe: one user message, no tools, no system
+// prompt. Option-dependent betas (fine-grained tool streaming) are therefore
+// probed under fixed defaults - sufficient while the allowlisted models keep
+// forceAdaptiveThinking: true in the catalog; a future allowlisted model with
+// tool- or thinking-conditional betas would have those dropped, same as today.
+const PROBE_CONTEXT: Context = { messages: [{ role: "user", content: "probe", timestamp: 0 }] };
+
+/**
+ * Discover the anthropic-beta list pi-ai would send for this model + auth by
+ * driving pi-ai's own request assembly against a capturing fetch. Zero
+ * network, zero tokens: the fetch records the request headers, then throws.
+ * Returns the captured header value, or null on any failure - missing
+ * optional peer (the guarded dynamic import() below), probe throw before
+ * capture, or no header present - and the caller falls back to the static
+ * reconstruction. maxRetries: 0 stops pi-ai's retry wrapper from re-driving
+ * the intentionally failing probe fetch.
+ */
+export async function probePiBetaHeader(
+	model: Model<any>,
+	auth: ProbeAuth,
+	fetchImpl?: (input: any, init?: any) => Promise<any>,
+): Promise<string | null> {
+	let captured: string | null = null;
+	const capturingFetch = async (input: any, init?: any): Promise<any> => {
+		const headers = init?.headers ?? input?.headers;
+		let value: unknown;
+		if (headers && typeof headers.get === "function") value = headers.get(BETA_HEADER);
+		else if (headers && typeof headers === "object") value = (headers as Record<string, unknown>)[BETA_HEADER];
+		if (typeof value === "string") captured = value;
+		throw new Error("fast-mode beta probe abort");
+	};
+	const options: StreamOptions = {
+		apiKey: auth.apiKey,
+		headers: auth.headers,
+		fetch: (fetchImpl ?? capturingFetch) as unknown as StreamOptions["fetch"],
+		maxRetries: 0,
+	};
+	try {
+		const { anthropicMessagesApi } = await import("@earendil-works/pi-ai/compat");
+		const stream = anthropicMessagesApi().stream(model, PROBE_CONTEXT, options);
+		await stream.result().catch(() => {});
+	} catch {
+		return captured;
+	}
+	return captured;
+}
+
 type State = { config: boolean; flag: boolean; live: boolean | null };
 
 export function resolveEnabled(s: State): boolean {
@@ -129,12 +202,18 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.setStatus(STATUS_KEY, shouldInject(enabled, ctx.model) ? "\u26a1 fast" : "\u26a1 n/a");
 	};
 
-	const detectOAuth = async (ctx: ExtensionContext): Promise<boolean | null> => {
+	type ResolvedAuth = ProbeAuth & { isOAuth: boolean };
+
+	const resolveAuth = async (ctx: ExtensionContext): Promise<ResolvedAuth | null> => {
 		if (!ctx.model) return null;
 		try {
 			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
 			if (!auth.ok) return null;
-			return typeof auth.apiKey === "string" && auth.apiKey.includes("sk-ant-oat");
+			return {
+				isOAuth: typeof auth.apiKey === "string" && auth.apiKey.includes("sk-ant-oat"),
+				apiKey: auth.apiKey,
+				headers: auth.headers,
+			};
 		} catch {
 			return null;
 		}
@@ -170,12 +249,18 @@ export default function (pi: ExtensionAPI) {
 			pendingFastHeader = false;
 			return;
 		}
-		const isOAuth = await detectOAuth(ctx);
-		if (isOAuth === null) {
+		const auth = await resolveAuth(ctx);
+		if (auth === null) {
 			pendingFastHeader = false;
 			return;
 		}
-		event.headers[BETA_HEADER] = buildBetaHeader(event.headers[BETA_HEADER], isOAuth);
+		const probed = await probePiBetaHeader(ctx.model!, auth);
+		event.headers[BETA_HEADER] = buildBetaHeader(
+			event.headers[BETA_HEADER],
+			auth.isOAuth,
+			probed,
+			needsFallbackBeta(ctx.model),
+		);
 		pendingFastHeader = true;
 	});
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-quiver",
-  "version": "5.2.1",
+  "version": "5.2.3",
   "description": "Personal pack of Pi coding-agent extensions: context-safe fetch, doc_to_md PDF/DOCX/PPTX-to-Markdown conversion, session naming, a themed ASCII startup header, Opus 4.8 fast mode, and a provider-stall watchdog.",
   "author": "Jacek Juraszek",
   "license": "MIT",