@oh-my-pi/pi-ai 18.4.3 → 18.4.4

package/src/dialect/minimax.ts

@@ -1,18 +1,13 @@
+import { escapeXmlText } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
 import {
 	ANTHROPIC_THINKING_TAG_PREFIXES,
 	AnthropicInbandScanner,
 	type AnthropicInbandScannerConfig,
 } from "./anthropic";
-import { buildArgShapes, type ToolArgShape } from "./coercion";
+import { buildArgShapes } from "./coercion";
 import dialectPrompt from "./minimax.md" with { type: "text" };
-import {
-	escapeXmlAttr,
-	escapeXmlText,
-	renderDelimitedThinking,
-	renderLegacyTextTranscript,
-	stringifyJson,
-} from "./rendering";
+import { renderDelimitedThinking, renderInvoke, renderInvokes, renderLegacyTextTranscript } from "./rendering";
 import type { DialectDefinition, DialectRenderOptions, DialectToolResult } from "./types";
 
 const MINIMAX_WRAPPER_TAGS: Readonly<Record<string, true>> = { tool_call: true };
@@ -65,22 +60,6 @@ function renderTranscript(messages: readonly Message[], options: DialectRenderOp
 	});
 }
 
-function renderInvoke(call: ToolCall, shape: ToolArgShape | undefined): string {
-	let body = `<invoke name="${escapeXmlAttr(call.name)}">`;
-	for (const key in call.arguments) {
-		const value = call.arguments[key];
-		const isString = shape?.stringArgs.has(key) === true;
-		const rendered = isString && typeof value === "string" ? value : stringifyJson(value);
-		body += `<parameter name="${escapeXmlAttr(key)}">${rendered}</parameter>`;
-	}
-	return `${body}</invoke>`;
-}
-
-function renderInvokes(calls: readonly ToolCall[], tools: NonNullable<DialectRenderOptions["tools"]>): string {
-	const shapes = buildArgShapes(tools);
-	return calls.map(call => renderInvoke(call, shapes.get(call.name))).join("\n");
-}
-
 const definition: DialectDefinition = {
 	dialect: "minimax",
 	prompt: dialectPrompt,

package/src/dialect/rendering.ts

@@ -1,5 +1,6 @@
 import { stringifyJson as stringifyJsonValue } from "@oh-my-pi/pi-utils";
 import type { AssistantMessage, Message, ToolCall, ToolResultMessage } from "../types";
+import { buildArgShapes, type ToolArgShape } from "./coercion";
 import type { DialectRenderOptions, DialectToolResult } from "./types";
 
 export function renderToolResponseResults(results: readonly DialectToolResult[]): string {
@@ -81,6 +82,23 @@ export function escapeXmlText(value: string): string {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 
+/** Render one Anthropic-style `<invoke>`; declared string args stay raw, everything else is JSON. */
+export function renderInvoke(call: ToolCall, shape: ToolArgShape | undefined): string {
+	let body = `<invoke name="${escapeXmlAttr(call.name)}">`;
+	for (const key in call.arguments) {
+		const value = call.arguments[key];
+		const isString = shape?.stringArgs.has(key) === true;
+		const rendered = isString && typeof value === "string" ? value : stringifyJson(value);
+		body += `<parameter name="${escapeXmlAttr(key)}">${rendered}</parameter>`;
+	}
+	return `${body}</invoke>`;
+}
+
+export function renderInvokes(calls: readonly ToolCall[], tools: NonNullable<DialectRenderOptions["tools"]>): string {
+	const shapes = buildArgShapes(tools);
+	return calls.map(call => renderInvoke(call, shapes.get(call.name))).join("\n");
+}
+
 export type AssistantTranscriptParts = {
 	readonly text: string;
 	readonly thinking: string;

package/src/dialect/xml.ts

@@ -1,13 +1,13 @@
 import type { Message, ToolCall } from "../types";
 import { AnthropicInbandScanner } from "./anthropic";
-import { buildArgShapes, type ToolArgShape } from "./coercion";
+import { buildArgShapes } from "./coercion";
 import { DeepSeekInbandScanner } from "./deepseek";
 import {
-	escapeXmlAttr,
 	renderDelimitedThinking,
+	renderInvoke,
+	renderInvokes,
 	renderLegacyTextTranscript,
 	renderToolResponseResults,
-	stringifyJson,
 } from "./rendering";
 import type {
 	DialectDefinition,
@@ -60,22 +60,6 @@ function renderTranscript(messages: readonly Message[], options: DialectRenderOp
 	});
 }
 
-function renderInvoke(call: ToolCall, shape: ToolArgShape | undefined): string {
-	let body = `<invoke name="${escapeXmlAttr(call.name)}">`;
-	for (const key in call.arguments) {
-		const value = call.arguments[key];
-		const isString = shape?.stringArgs.has(key) === true;
-		const rendered = isString && typeof value === "string" ? value : stringifyJson(value);
-		body += `<parameter name="${escapeXmlAttr(key)}">${rendered}</parameter>`;
-	}
-	return `${body}</invoke>`;
-}
-
-function renderInvokes(calls: readonly ToolCall[], tools: NonNullable<DialectRenderOptions["tools"]>): string {
-	const shapes = buildArgShapes(tools);
-	return calls.map(call => renderInvoke(call, shapes.get(call.name))).join("\n");
-}
-
 const definition: DialectDefinition = {
 	dialect: "xml",
 	prompt: dialectPrompt,

package/src/images/openai-images.ts

@@ -1,5 +1,6 @@
 import type { Model } from "@oh-my-pi/pi-catalog/types";
 import * as AIError from "../error";
+import { resolveXaiBaseUrl } from "../providers/xai-base-url";
 import {
 	decodeImageResponse,
 	imageBaseUrl,
@@ -54,11 +55,16 @@ export async function generateOpenAIImage(
 			: { ...generationBody, images: references }
 		: { ...generationBody, input_references: references };
 	const baseUrl = imageBaseUrl(model);
+	// xAI resolves the endpoint per bearer: XAI_BASE_URL never receives an xai-oauth OAuth access token.
+	const endpoint = (path: string) =>
+		isXAI
+			? (bearer: string) => `${resolveXaiBaseUrl(model.provider, baseUrl, bearer) ?? baseUrl}${path}`
+			: `${baseUrl}${path}`;
 	let response: unknown;
 	if (references.length === 0) {
 		response = await postJson({
 			model,
-			url: `${baseUrl}/images/generations`,
+			url: endpoint("/images/generations"),
 			body: generationBody,
 			apiKey: options.apiKey,
 			fetch: fetchImpl,
@@ -78,7 +84,7 @@ export async function generateOpenAIImage(
 				}
 				response = await postMultipart({
 					model,
-					url: `${baseUrl}/images/edits`,
+					url: endpoint("/images/edits"),
 					body: form,
 					apiKey: options.apiKey,
 					fetch: fetchImpl,
@@ -87,7 +93,7 @@ export async function generateOpenAIImage(
 			} else {
 				response = await postJson({
 					model,
-					url: `${baseUrl}/images/edits`,
+					url: endpoint("/images/edits"),
 					body,
 					apiKey: options.apiKey,
 					fetch: fetchImpl,
@@ -98,7 +104,7 @@ export async function generateOpenAIImage(
 			if (!(error instanceof AIError.ProviderHttpError) || error.status !== 404) throw error;
 			response = await postJson({
 				model,
-				url: `${baseUrl}/images/generations`,
+				url: endpoint("/images/generations"),
 				body,
 				apiKey: options.apiKey,
 				fetch: fetchImpl,

package/src/images/shared.ts

@@ -69,9 +69,12 @@ async function parseImageApiResponse(model: Model, response: Response): Promise<
 	}
 }
 
+/** Request URL, or a builder for routes that depend on the bearer (xAI's `XAI_BASE_URL` rule). */
+type ImageRequestUrl = string | ((bearer: string) => string);
+
 export async function postJson(options: {
 	model: Model;
-	url: string;
+	url: ImageRequestUrl;
 	body: unknown;
 	apiKey: ApiKey;
 	fetch: FetchImpl;
@@ -80,7 +83,8 @@ export async function postJson(options: {
 	return withAuth(
 		options.apiKey,
 		async key => {
-			const response = await options.fetch(options.url, {
+			const url = typeof options.url === "string" ? options.url : options.url(key);
+			const response = await options.fetch(url, {
 				method: "POST",
 				headers: {
 					...(await modelHeaders(options.model, options.signal)),
@@ -99,7 +103,7 @@ export async function postJson(options: {
 
 export async function postMultipart(options: {
 	model: Model;
-	url: string;
+	url: ImageRequestUrl;
 	body: FormData;
 	apiKey: ApiKey;
 	fetch: FetchImpl;
@@ -108,7 +112,8 @@ export async function postMultipart(options: {
 	return withAuth(
 		options.apiKey,
 		async key => {
-			const response = await options.fetch(options.url, {
+			const url = typeof options.url === "string" ? options.url : options.url(key);
+			const response = await options.fetch(url, {
 				method: "POST",
 				headers: {
 					...(await modelHeaders(options.model, options.signal)),

package/src/providers/amazon-bedrock.ts

@@ -56,6 +56,7 @@ import { invalidateAwsCredentialCache, resolveAwsCredentials } from "./aws-crede
 import { decodeEventStream } from "./aws-eventstream";
 import { signRequest } from "./aws-sigv4";
 import { parseAnthropicInputTransformations, THINKING_BINDING_CONTROLS_BETA } from "./anthropic-wire";
+import { isBedrockRequestMetadataValue } from "./bedrock-request-metadata";
 import { transformMessages } from "./transform-messages";
 
 /**
@@ -381,9 +382,7 @@ interface MetadataEvent {
 	};
 }
 
-const REQUEST_METADATA_PATTERN = /^[a-zA-Z0-9\s:_@$#=/+,\-.]*$/;
 const REQUEST_METADATA_MAX_ENTRIES = 16;
-const REQUEST_METADATA_MAX_LENGTH = 256;
 
 /**
  * Bedrock rejects the whole invocation on a malformed `requestMetadata` entry.
@@ -400,10 +399,8 @@ function sanitizeRequestMetadata(raw: unknown): Record<string, string> | undefin
 		if (
 			typeof value !== "string" ||
 			key.length < 1 ||
-			key.length > REQUEST_METADATA_MAX_LENGTH ||
-			!REQUEST_METADATA_PATTERN.test(key) ||
-			value.length > REQUEST_METADATA_MAX_LENGTH ||
-			!REQUEST_METADATA_PATTERN.test(value) ||
+			!isBedrockRequestMetadataValue(key) ||
+			!isBedrockRequestMetadataValue(value) ||
 			kept >= REQUEST_METADATA_MAX_ENTRIES
 		) {
 			dropped.push(key);

package/src/providers/anthropic-compaction.ts

@@ -1,4 +1,4 @@
-import { isOfficialAnthropicApiUrl } from "@oh-my-pi/pi-catalog/compat/anthropic";
+import { isBedrockAnthropicRoute, isOfficialAnthropicApiUrl } from "@oh-my-pi/pi-catalog/compat/anthropic";
 import type { Model } from "../types";
 import type { AnthropicMessagesClientLike } from "./anthropic-client";
 import { normalizeAnthropicBaseUrl, resolveDirectAnthropicBaseUrl } from "./anthropic-state";
@@ -46,6 +46,15 @@ export function supportsAnthropicCompaction(model: Model<"anthropic-messages">,
 		(model.provider === "anthropic"
 			? resolveDirectAnthropicBaseUrl(model)
 			: normalizeAnthropicBaseUrl(model.baseUrl));
+	// Bedrock's Anthropic Messages API implements on-demand compaction. The flag is detected
+	// from a Bedrock `/anthropic` baseUrl, or set in models.yml for a proxy or a reroute; it
+	// applies to the model's own endpoint or a Bedrock `/anthropic` route it reaches.
+	if (
+		model.compat.bedrockMessagesApi === true &&
+		(isBedrockAnthropicRoute(route) || route === normalizeAnthropicBaseUrl(model.baseUrl))
+	) {
+		return true;
+	}
 	return (
 		isSupportedCompactionEndpoint(route) &&
 		(model.compat.firstPartyProvider === true ||

package/src/providers/anthropic-wire.ts

@@ -272,7 +272,18 @@ export type ThinkingConfigAdaptive = {
 	block_binding?: ThinkingBlockBinding;
 };
 
-export type ThinkingConfigParam = ThinkingConfigEnabled | ThinkingConfigDisabled | ThinkingConfigAdaptive;
+/**
+ * Sonnet 5.5's replacement for `disabled`: no up-front thinking, progress
+ * updates between tool calls only. Takes no other field, and effort above
+ * `high` is rejected alongside it.
+ */
+export type ThinkingConfigBetweenTools = { type: "between_tools" };
+
+export type ThinkingConfigParam =
+	| ThinkingConfigEnabled
+	| ThinkingConfigDisabled
+	| ThinkingConfigAdaptive
+	| ThinkingConfigBetweenTools;
 
 export type OutputConfig = {
 	/** Adaptive-thinking effort level (effort beta). */

package/src/providers/anthropic.ts

@@ -155,6 +155,7 @@ import {
 	resolveAnthropicMetadataUserId,
 	stripClaudeToolPrefix,
 } from "./anthropic-identity";
+import { fitBedrockAnthropicPayload } from "./bedrock-anthropic";
 import {
 	anthropicProviderSessionStateKey,
 	clearAnthropicFastModeFallback,
@@ -2264,6 +2265,8 @@ const streamAnthropicOnce = (
 					nextParams = replacementPayload as typeof nextParams;
 				}
 				if (nextParams.compaction) stripCompactionIncompatibleParams(nextParams);
+				// After `onPayload`, so a hook cannot restore a field Bedrock rejects.
+				if (model.compat.bedrockMessagesApi) fitBedrockAnthropicPayload(nextParams);
 				nextParams = toWellFormedDeep(nextParams) as typeof nextParams;
 				rawRequestDump = {
 					provider: model.provider,
@@ -3827,22 +3830,17 @@ function ensureMaxTokensForThinking(params: MessageCreateParamsStreaming, maxAll
 	const budgetTokens = thinking.budget_tokens ?? 0;
 	if (budgetTokens <= 0) return;
 
-	const currentMaxTokens = Math.min(params.max_tokens ?? maxAllowedTokens, maxAllowedTokens);
-	const raisedMaxTokens = Math.min(
-		Math.max(currentMaxTokens, budgetTokens + OUTPUT_FALLBACK_BUFFER),
-		maxAllowedTokens,
-	);
-	params.max_tokens = raisedMaxTokens;
+	const output = budgetThinkingOutput(params.max_tokens, budgetTokens, maxAllowedTokens);
+	params.max_tokens = output.maxTokens;
 
-	if (budgetTokens + OUTPUT_FALLBACK_BUFFER <= raisedMaxTokens) return;
+	if (output.budgetTokens === budgetTokens) return;
 
-	const clampedBudget = raisedMaxTokens - OUTPUT_FALLBACK_BUFFER;
-	if (clampedBudget <= 0) {
+	if (output.budgetTokens <= 0) {
 		throw new AIError.ConfigurationError(
-			`Anthropic thinking budget requires max_tokens greater than ${OUTPUT_FALLBACK_BUFFER}; got ${raisedMaxTokens}`,
+			`Anthropic thinking budget requires max_tokens greater than ${OUTPUT_FALLBACK_BUFFER}; got ${output.maxTokens}`,
 		);
 	}
-	thinking.budget_tokens = clampedBudget;
+	thinking.budget_tokens = output.budgetTokens;
 }
 
 function applyCacheControlToLastBlock(blocks: ContentBlockParam[], cacheControl: AnthropicCacheControl): boolean {
@@ -4128,6 +4126,41 @@ function usesAdaptiveThinkingTagOnly(model: Model<"anthropic-messages">): boolea
 	return thinking.efforts.length > 0;
 }
 
+/**
+ * True when enabled thinking on `model` is budget thinking
+ * (`thinking.type: "enabled"` with `budget_tokens`) rather than adaptive.
+ */
+export function usesBudgetThinking(model: Model<"anthropic-messages">): boolean {
+	return model.thinking?.mode !== "anthropic-adaptive" || model.compat.disableAdaptiveThinking === true;
+}
+
+/** The most output tokens a request to `model` may ask for (`max_tokens` ceiling). */
+export function anthropicOutputLimit(model: Model<"anthropic-messages">): number {
+	return model.maxTokens ?? UNKNOWN_MODEL_MAX_OUTPUT_TOKENS;
+}
+
+/**
+ * The `max_tokens` and thinking budget of budget thinking: `max_tokens`
+ * rises to leave {@link OUTPUT_FALLBACK_BUFFER} visible output tokens after
+ * the budget, within `maxAllowedTokens`, and the budget shrinks when that
+ * ceiling leaves less (a non-positive budget means the ceiling is too low).
+ */
+export function budgetThinkingOutput(
+	maxTokens: number | undefined,
+	budgetTokens: number,
+	maxAllowedTokens: number,
+): { maxTokens: number; budgetTokens: number } {
+	const currentMaxTokens = Math.min(maxTokens ?? maxAllowedTokens, maxAllowedTokens);
+	const raisedMaxTokens = Math.min(
+		Math.max(currentMaxTokens, budgetTokens + OUTPUT_FALLBACK_BUFFER),
+		maxAllowedTokens,
+	);
+	return {
+		maxTokens: raisedMaxTokens,
+		budgetTokens: Math.min(budgetTokens, raisedMaxTokens - OUTPUT_FALLBACK_BUFFER),
+	};
+}
+
 /**
  * True for adaptive-only Claude models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5)
  * that reject `thinking.type: "disabled"`. Turning thinking off on these models
@@ -4550,8 +4583,7 @@ function buildParams(
 			const thinkingOptions = options ?? {};
 			const mode = model.thinking?.mode;
 			const effort = resolveAnthropicAdaptiveEffort(model, thinkingOptions);
-			const compat = model.compat;
-			if (mode === "anthropic-adaptive" && !compat.disableAdaptiveThinking) {
+			if (!usesBudgetThinking(model)) {
 				const adaptive: { type: "adaptive"; display?: AnthropicThinkingDisplay } = { type: "adaptive" };
 				// Starting with Claude Opus 4.7 and Claude Fable/Mythos 5, adaptive thinking
 				// content is omitted from the response by default. Opt into summarized
@@ -4573,7 +4605,12 @@ function buildParams(
 				if (mode === "anthropic-budget-effort" && effort && effort !== "adaptive") outputConfigEffort = effort;
 			}
 		} else if (options?.thinkingEnabled === false) {
-			if (isAdaptiveOnlyThinking(model)) {
+			if (model.compat.supportsBetweenToolsThinking) {
+				// Sonnet 5.5 rejects `disabled` with a 400; `between_tools` is its lowest
+				// thinking setting. It takes no other field and leaves effort untouched:
+				// pinning `low` here would cap the whole turn's quality, not only thinking.
+				thinking = { type: "between_tools" };
+			} else if (isAdaptiveOnlyThinking(model)) {
 				// Adaptive-only Claude models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5) reject
 				// `thinking.type: "disabled"` — adaptive thinking cannot be switched off.
 				// Omit the thinking field (the API defaults to adaptive) and pin the
@@ -4643,6 +4680,12 @@ function buildParams(
 		model.compat.supportsPerMessageEffort === true,
 		compactionReplay,
 	);
+	// `between_tools` returns a 400 at `xhigh`/`max` effort, and the effort in
+	// force from earlier turns outlives a thinking toggle. Fall back to the
+	// default adaptive request, which accepts every effort level.
+	if (thinking?.type === "between_tools" && (effortPlan.topLevel === "xhigh" || effortPlan.topLevel === "max")) {
+		thinking = undefined;
+	}
 	const wireMessages = convertAnthropicMessages(
 		insertAnthropicControlMarkers(context.messages, [...toolPlan.inserts, ...effortPlan.inserts]),
 		effectiveModel,
@@ -4683,7 +4726,7 @@ function buildParams(
 
 	// OAuth and API-key requests alike get the full model ceiling; Claude Code
 	// itself requests 128k on Opus 5.5.
-	const maxOutputTokens = model.maxTokens ?? UNKNOWN_MODEL_MAX_OUTPUT_TOKENS;
+	const maxOutputTokens = anthropicOutputLimit(model);
 
 	// A caller-owned client targets its own endpoint: route body betas by the
 	// client's URL when it exposes one, not the model's routing. Otherwise the

package/src/providers/aws-sigv4.ts

@@ -61,7 +61,7 @@ const UNSIGNABLE: Record<string, true> = {
  * `ArrayBuffer`, which is what `crypto.subtle.{digest,sign,importKey}` requires
  * under the strict TS DOM typings. No-op when already strict.
  */
-function asStrict(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
+export function asStrict(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
 	if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
 		return bytes as Uint8Array<ArrayBuffer>;
 	}

package/src/providers/bedrock-anthropic.ts

@@ -0,0 +1,30 @@
+import { isRecord } from "@oh-my-pi/pi-utils";
+import { extractClaudeMetadataSessionId } from "./anthropic-identity";
+import { isBedrockRequestMetadataValue } from "./bedrock-request-metadata";
+
+/**
+ * Fit an Anthropic request body to Bedrock's Anthropic Messages API
+ * (`compat.bedrockMessagesApi`): both `/anthropic` routes reject the tool
+ * `strict` field, and bedrock-runtime rejects a `metadata.user_id` outside
+ * Bedrock's request-metadata pattern. A user id that fits is kept, otherwise
+ * its embedded session id, otherwise the metadata is dropped. Mutates and
+ * returns `payload`.
+ */
+export function fitBedrockAnthropicPayload<T>(payload: T): T {
+	if (!isRecord(payload)) return payload;
+	const body: Record<string, unknown> = payload;
+	if (Array.isArray(body.tools)) {
+		for (const tool of body.tools) {
+			if (isRecord(tool)) delete tool.strict;
+		}
+	}
+	if (body.metadata === undefined) return payload;
+	const userId = isRecord(body.metadata) ? body.metadata.user_id : undefined;
+	const fitted =
+		typeof userId === "string" && isBedrockRequestMetadataValue(userId)
+			? userId
+			: extractClaudeMetadataSessionId(userId);
+	if (fitted && isBedrockRequestMetadataValue(fitted)) body.metadata = { user_id: fitted };
+	else delete body.metadata;
+	return payload;
+}

package/src/providers/bedrock-request-metadata.ts

@@ -0,0 +1,6 @@
+const BEDROCK_REQUEST_METADATA_PATTERN = /^[a-zA-Z0-9\s:_@$#=/+,\-.]*$/;
+
+/** Check Bedrock's request-metadata character and length limits. Keys must also be nonempty. */
+export function isBedrockRequestMetadataValue(value: string): boolean {
+	return value.length <= 256 && BEDROCK_REQUEST_METADATA_PATTERN.test(value);
+}

package/src/providers/connect-error-detail.ts

@@ -1,4 +1,4 @@
-import { truncate } from "@oh-my-pi/pi-utils";
+import { isRecord, truncate } from "@oh-my-pi/pi-utils";
 
 /**
  * Connect-protocol end-stream error formatting.
@@ -21,10 +21,6 @@ const GENERIC_CONNECT_ERROR_MESSAGES = new Set(["", "error", "unknown", "unknown
 /** Upper bound for appended trailer context so errors stay log-line sized. */
 const MAX_EXTRA_DETAIL_CHARS = 400;
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 function safeJson(value: unknown): string | undefined {
 	try {
 		const text = typeof value === "string" ? value : JSON.stringify(value);

package/src/providers/cursor/interaction-query.ts

@@ -32,7 +32,8 @@ type ProtoUnknownBag = { $unknown?: ProtoUnknownField[] };
 type InteractionQueryCase = NonNullable<InteractionQuery["query"]["case"]>;
 type InteractionResult = Exclude<InteractionResponse["result"], { case: undefined; value?: undefined }>;
 
-function frameConnectMessage(data: Uint8Array, flags = 0): Buffer {
+/** Wrap one Connect-protocol message: 1 flag byte + 4-byte big-endian length + payload. */
+export function frameConnectMessage(data: Uint8Array, flags = 0): Buffer {
 	const frame = Buffer.alloc(5 + data.length);
 	frame[0] = flags;
 	frame.writeUInt32BE(data.length, 1);
@@ -46,7 +47,8 @@ function isProtoUnknownField(value: unknown): value is ProtoUnknownField {
 	return typeof value.no === "number" && typeof value.wireType === "number" && value.data instanceof Uint8Array;
 }
 
-function protoUnknownFields(message: object): ProtoUnknownField[] {
+/** Well-formed protobuf-es `$unknown` entries on `message`; anything else on the bag is ignored. */
+export function protoUnknownFields(message: object): ProtoUnknownField[] {
 	if (!("$unknown" in message) || !Array.isArray(message.$unknown)) return [];
 	return message.$unknown.filter(isProtoUnknownField);
 }

package/src/providers/cursor.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs/promises";
 import http2 from "node:http2";
+import { cursorModelParameters } from "@oh-my-pi/pi-catalog/compat/behavior";
 import { isCursorMaxModeWireId } from "@oh-my-pi/pi-catalog/compat/collapse";
 import { classifyModel, collapseVariantId } from "@oh-my-pi/pi-catalog/compat/taxonomy";
 import type {
@@ -246,7 +247,7 @@ import {
 	piTimeout,
 	shellTimeoutSeconds,
 } from "./cursor/exec-modern";
-import { handleInteractionQuery } from "./cursor/interaction-query";
+import { frameConnectMessage, handleInteractionQuery, protoUnknownFields } from "./cursor/interaction-query";
 
 export const CURSOR_API_URL = "https://api2.cursor.sh";
 export const CURSOR_CLIENT_VERSION = "cli-2026.07.23-e383d2b";
@@ -407,14 +408,14 @@ function log(type: string, subtype?: string, data?: unknown): void {
 	void appendCursorDebugLog(entry);
 }
 
-function frameConnectMessage(data: Uint8Array, flags = 0): Buffer {
-	const frame = Buffer.alloc(5 + data.length);
-	frame[0] = flags;
-	frame.writeUInt32BE(data.length, 1);
-	frame.set(data, 5);
-	return frame;
+/**
+ * Write one client message. Once the server's end frame has half-closed our
+ * side, late writes (heartbeats, exec replies from a handler still running)
+ * are dropped: writing after `end()` would error the stream.
+ */
+function writeClientMessage(h2Request: http2.ClientHttp2Stream, data: Uint8Array): void {
+	if (!h2Request.writableEnded) h2Request.write(frameConnectMessage(data));
 }
-
 class ConnectEndStreamError extends AIError.ProviderResponseError {
 	readonly diagnosticMessage: string;
 
@@ -845,6 +846,11 @@ function streamCursorWithWireMode(
 						if (endError) {
 							endStreamError = endError;
 							h2Request?.close();
+						} else {
+							// The end frame is the server's last message. Half-close our
+							// side so the stream can finish: a CONNECT proxy holds the
+							// HTTP/2 stream open until the client ends its request.
+							h2Request?.end();
 						}
 						continue;
 					}
@@ -903,7 +909,7 @@ function streamCursorWithWireMode(
 					message: { case: "clientHeartbeat", value: create(ClientHeartbeatSchema, {}) },
 				});
 				const heartbeatBytes = toBinary(AgentClientMessageSchema, heartbeatMessage);
-				h2Request.write(frameConnectMessage(heartbeatBytes));
+				writeClientMessage(h2Request, heartbeatBytes);
 			};
 
 			const closeDebugLog = async (): Promise<void> => {
@@ -1207,8 +1213,6 @@ export async function handleServerMessage(
 	}
 }
 
-type ProtoUnknownField = { no: number; wireType: number; data: Uint8Array };
-
 type HostedFetchCall = {
 	args?: { url?: string; toolCallId?: string };
 	result?: { result?: { case?: string; value?: { content?: string; error?: string; url?: string } } };
@@ -1250,11 +1254,6 @@ function describeHostedFetchResult(call: HostedFetchCall | undefined): { text: s
 	return { text: "Fetch completed", isError: false };
 }
 
-function protoUnknownFields(message: object): ProtoUnknownField[] {
-	const raw = (message as { $unknown?: ProtoUnknownField[] }).$unknown;
-	return Array.isArray(raw) ? raw : [];
-}
-
 function handleKvServerMessage(
 	kvMsg: KvServerMessage,
 	blobStore: Map<string, Uint8Array>,
@@ -1281,7 +1280,7 @@ function handleKvServerMessage(
 		});
 
 		const responseBytes = toBinary(AgentClientMessageSchema, kvClientMessage);
-		h2Request.write(frameConnectMessage(responseBytes));
+		writeClientMessage(h2Request, responseBytes);
 
 		log("kvClient", "getBlobResult", { blobId: blobIdKey.slice(0, 40) });
 	} else if (kvCase === "setBlobArgs") {
@@ -1302,7 +1301,7 @@ function handleKvServerMessage(
 		});
 
 		const responseBytes = toBinary(AgentClientMessageSchema, kvClientMessage);
-		h2Request.write(frameConnectMessage(responseBytes));
+		writeClientMessage(h2Request, responseBytes);
 
 		log("kvClient", "setBlobResult", { blobId: blobIdKey.slice(0, 40) });
 	}
@@ -2604,7 +2603,7 @@ function sendExecClientMessage<TCase extends NonNullable<ExecClientMessage["mess
 	});
 
 	const responseBytes = toBinary(AgentClientMessageSchema, clientMessage);
-	h2Request.write(frameConnectMessage(responseBytes));
+	writeClientMessage(h2Request, responseBytes);
 
 	log("execClientMessage", messageCase, value);
 }
@@ -2640,7 +2639,7 @@ function sendExecClientThrow(
 	const clientMessage = create(AgentClientMessageSchema, {
 		message: { case: "execClientControlMessage", value: controlMessage },
 	});
-	h2Request.write(frameConnectMessage(toBinary(AgentClientMessageSchema, clientMessage)));
+	writeClientMessage(h2Request, toBinary(AgentClientMessageSchema, clientMessage));
 	log("execClientControl", "throw", { id: execMsg.id, execId: execMsg.execId, error, errorCode });
 	sendExecClientStreamClose(h2Request, execMsg);
 }
@@ -2658,7 +2657,7 @@ function sendExecClientStreamClose(h2Request: http2.ClientHttp2Stream, execMsg:
 		message: { case: "execClientControlMessage", value: closeMessage },
 	});
 	const responseBytes = toBinary(AgentClientMessageSchema, clientMessage);
-	h2Request.write(frameConnectMessage(responseBytes));
+	writeClientMessage(h2Request, responseBytes);
 	log("execClientControl", "streamClose", { id: execMsg.id, execId: execMsg.execId });
 }
 
@@ -5487,13 +5486,18 @@ function resolveCursorWireModel(
 			};
 		}
 	}
-	// A bare `composer-2.5` id resolves to the Fast variant server-side
-	// (can1357/oh-my-pi#9012). Pin the Standard tier explicitly; `-fast`
-	// selections keep the Fast lane by omitting the parameter.
-	if (wireModelId === "composer-2.5") {
+	// Fixed per-model parameters come from catalog KDL (`cursor-model-parameter`
+	// in `runtime/behavior.kdl`). A bare `composer-2.5` id resolves to the Fast
+	// variant server-side (can1357/oh-my-pi#9012), so the catalog pins the
+	// Standard tier with `fast=false`; `-fast` selections keep the Fast lane by
+	// declaring no parameter.
+	const fixedParameters = cursorModelParameters(wireModelId);
+	if (fixedParameters.length > 0) {
 		return {
 			modelId: wireModelId,
-			parameters: [create(RequestedModel_ModelParameterbytesSchema, { id: "fast", value: "false" })],
+			parameters: fixedParameters.map(({ id, value }) =>
+				create(RequestedModel_ModelParameterbytesSchema, { id, value }),
+			),
 			maxMode,
 		};
 	}