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

package/src/auth-broker/snapshot-cache.ts

@@ -9,6 +9,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { asStrict } from "../providers/aws-sigv4";
 import type { SnapshotResponse } from "./types";
 
 const MAGIC = new Uint8Array([0x4f, 0x4d, 0x50, 0x53]); // "OMPS"
@@ -210,15 +211,6 @@ async function deriveAesKey(token: string, usages: Array<"encrypt" | "decrypt">)
 	return globalThis.crypto.subtle.importKey("raw", digest, AES_ALGORITHM, false, usages);
 }
 
-function asStrict(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
-	if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
-		return bytes as Uint8Array<ArrayBuffer>;
-	}
-	const copy = new Uint8Array(bytes.byteLength);
-	copy.set(bytes);
-	return copy;
-}
-
 function randomHex(byteLength: number): string {
 	const bytes = new Uint8Array(byteLength);
 	globalThis.crypto.getRandomValues(bytes);

package/src/dialect/anthropic.ts

@@ -1,14 +1,8 @@
-import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
+import { escapeXmlText, parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
 import dialectPrompt from "./anthropic.md" with { type: "text" };
-import { buildArgShapes, buildStringArgsResolver, mintToolCallId, type ToolArgShape } from "./coercion";
-import {
-	escapeXmlAttr,
-	escapeXmlText,
-	renderDelimitedThinking,
-	renderLegacyTextTranscript,
-	stringifyJson,
-} from "./rendering";
+import { buildArgShapes, buildStringArgsResolver, mintToolCallId } from "./coercion";
+import { renderDelimitedThinking, renderInvoke, renderInvokes, renderLegacyTextTranscript } from "./rendering";
 import type {
 	DialectDefinition,
 	DialectRenderOptions,
@@ -578,22 +572,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: "anthropic",
 	prompt: dialectPrompt,

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/thinking.ts

@@ -36,6 +36,18 @@ const TAGS: readonly Tag[] = [
 const OPENS = TAGS.map(tag => tag.open);
 const IMPLIED_OPEN_TAGS = TAGS.filter(tag => tag.impliedOpen);
 const IMPLIED_OPEN_DELIMITERS = [...OPENS, ...IMPLIED_OPEN_TAGS.map(tag => tag.close)];
+/** A hold needs the buffer tail to be a proper prefix of some delimiter, so it must be shorter than this. */
+const MAX_DELIMITER_LENGTH = Math.max(...IMPLIED_OPEN_DELIMITERS.map(delimiter => delimiter.length));
+const BACKTICK = 0x60;
+const BOUNDARY_LEAD_CODES = [...IMPLIED_OPEN_DELIMITERS.map(delimiter => delimiter.charCodeAt(0)), BACKTICK];
+/**
+ * `1` at the char code of every character a {@link scanVisible} boundary can
+ * start on: the first character of any delimiter (a tag open, an implied close,
+ * or a partial of either) and the backtick. Every other character — including
+ * any code past the table — is skipped without comparing.
+ */
+const BOUNDARY_LEAD = new Uint8Array(Math.max(...BOUNDARY_LEAD_CODES) + 1);
+for (const code of BOUNDARY_LEAD_CODES) BOUNDARY_LEAD[code] = 1;
 
 export interface ThinkingInbandScannerOptions {
 	/**
@@ -240,20 +252,26 @@ type VisibleHit =
  */
 function scanVisible(buffer: string, final: boolean, impliedOpen: boolean): VisibleHit {
 	const delimiters = impliedOpen ? IMPLIED_OPEN_DELIMITERS : OPENS;
+	// Only the tail can be a proper prefix of a delimiter.
+	const holdFrom = final ? buffer.length : buffer.length - MAX_DELIMITER_LENGTH + 1;
 	for (let i = 0; i < buffer.length; i++) {
-		const tag = TAGS.find(candidate => buffer.startsWith(candidate.open, i));
-		if (tag) return { kind: "tag", index: i, tag };
+		const code = buffer.charCodeAt(i);
+		if (code >= BOUNDARY_LEAD.length || BOUNDARY_LEAD[code] === 0) continue;
+		for (const tag of TAGS) {
+			if (buffer.startsWith(tag.open, i)) return { kind: "tag", index: i, tag };
+		}
 		if (impliedOpen) {
-			const closed = IMPLIED_OPEN_TAGS.find(candidate => buffer.startsWith(candidate.close, i));
-			if (closed) return { kind: "impliedClose", index: i, tag: closed };
+			for (const tag of IMPLIED_OPEN_TAGS) {
+				if (buffer.startsWith(tag.close, i)) return { kind: "impliedClose", index: i, tag };
+			}
 		}
-		if (!final) {
+		if (i >= holdFrom) {
 			const rest = buffer.slice(i);
 			if (delimiters.some(delimiter => delimiter.length > rest.length && delimiter.startsWith(rest))) {
 				return { kind: "hold", index: i };
 			}
 		}
-		if (buffer[i] === "`") {
+		if (code === BACKTICK) {
 			const ticks = backtickRun(buffer, i);
 			if (!final && i + ticks === buffer.length) return { kind: "hold", index: i };
 			return { kind: "code", index: i, ticks };

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-hosted.ts

@@ -1,4 +1,4 @@
-import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import { type Api, type Model, modelKind } from "@oh-my-pi/pi-catalog/types";
 import {
 	applyCodexResidencyHeader,
 	CODEX_BASE_URL,
@@ -155,7 +155,10 @@ export async function generateHostedImage(
 		action: content.length > 1 ? "edit" : "generate",
 		output_format: "webp",
 		...(size ? { size } : {}),
-		...(model.api === "openai-responses" ? { model: model.requestModelId ?? model.id } : {}),
+		// A chat model generating on its own lets the host pick the image model.
+		...(model.api === "openai-responses" && modelKind(model) === "image"
+			? { model: model.requestModelId ?? model.id }
+			: {}),
 	};
 	const body = {
 		model: carrier.requestModelId ?? carrier.id,

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);
@@ -446,6 +443,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 		};
 
 		const blocks = output.content as Block[];
+		const contentIndexByBlockIndex = new Map<number, number>();
 		let rawRequestDump: RawHttpRequestDump | undefined;
 		const region = resolveBedrockRegion(model.id, options);
 
@@ -640,7 +638,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				if (messageType === "exception") {
 					const exceptionType = message.headers[":exception-type"] || "Exception";
 					const payload = safeParsePayload(message.payload) as { message?: string } | undefined;
-					const errorMessage = payload?.message || new TextDecoder().decode(message.payload);
+					const errorMessage = payload?.message || PAYLOAD_DECODER.decode(message.payload);
 					const text = `${exceptionType}: ${errorMessage}`;
 					throw new AIError.BedrockApiError(text, bedrockStreamExceptionStatus(exceptionType), {
 						code: exceptionType,
@@ -648,7 +646,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				}
 				if (messageType === "error") {
 					const code = message.headers[":error-code"] || "UnknownError";
-					const errorMessage = message.headers[":error-message"] || new TextDecoder().decode(message.payload);
+					const errorMessage = message.headers[":error-message"] || PAYLOAD_DECODER.decode(message.payload);
 					throw new AIError.BedrockApiError(`${code}: ${errorMessage}`, bedrockStreamExceptionStatus(code), {
 						code,
 					});
@@ -673,16 +671,35 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 					}
 					case "contentBlockStart": {
 						if (!firstTokenTime) firstTokenTime = performance.now();
-						handleContentBlockStart(payload as ContentBlockStartEvent, blocks, output, stream, sentinelInjected);
+						handleContentBlockStart(
+							payload as ContentBlockStartEvent,
+							blocks,
+							contentIndexByBlockIndex,
+							output,
+							stream,
+							sentinelInjected,
+						);
 						break;
 					}
 					case "contentBlockDelta": {
 						if (!firstTokenTime) firstTokenTime = performance.now();
-						handleContentBlockDelta(payload as ContentBlockDeltaEvent, blocks, output, stream);
+						handleContentBlockDelta(
+							payload as ContentBlockDeltaEvent,
+							blocks,
+							contentIndexByBlockIndex,
+							output,
+							stream,
+						);
 						break;
 					}
 					case "contentBlockStop": {
-						handleContentBlockStop(payload as ContentBlockStopEvent, blocks, output, stream);
+						handleContentBlockStop(
+							payload as ContentBlockStopEvent,
+							blocks,
+							contentIndexByBlockIndex,
+							output,
+							stream,
+						);
 						break;
 					}
 					case "messageStop": {
@@ -782,18 +799,40 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 	return stream;
 };
 
+/** Shared across events: every payload decode is a complete, non-streaming call. */
+const PAYLOAD_DECODER = new TextDecoder();
+
 function safeParsePayload(payload: Uint8Array): unknown {
 	if (payload.length === 0) return {};
 	try {
-		return JSON.parse(new TextDecoder().decode(payload));
+		return JSON.parse(PAYLOAD_DECODER.decode(payload));
 	} catch {
 		return undefined;
 	}
 }
 
+/**
+ * Append a streamed block and index it by Bedrock's `contentBlockIndex`, so
+ * per-delta routing is an O(1) lookup instead of a scan over every block
+ * (quadratic over a long turn). The first block registered for an index wins,
+ * as the first-match scan did. Returns the block's content index.
+ */
+function pushStreamBlock(
+	blocks: Block[],
+	contentIndexByBlockIndex: Map<number, number>,
+	block: Block,
+	contentBlockIndex: number,
+): number {
+	const contentIndex = blocks.length;
+	blocks.push(block);
+	if (!contentIndexByBlockIndex.has(contentBlockIndex)) contentIndexByBlockIndex.set(contentBlockIndex, contentIndex);
+	return contentIndex;
+}
+
 function handleContentBlockStart(
 	event: ContentBlockStartEvent,
 	blocks: Block[],
+	contentIndexByBlockIndex: Map<number, number>,
 	output: AssistantMessage,
 	stream: AssistantMessageEventStream,
 	sentinelInjected: boolean,
@@ -815,29 +854,29 @@ function handleContentBlockStart(
 			[kStreamingPartialJson]: "",
 			[kStreamingBlockIndex]: index,
 		};
-		output.content.push(block);
-		stream.push({ type: "toolcall_start", contentIndex: blocks.length - 1, partial: output });
+		const contentIndex = pushStreamBlock(blocks, contentIndexByBlockIndex, block, index);
+		stream.push({ type: "toolcall_start", contentIndex, partial: output });
 	}
 }
 
 function handleContentBlockDelta(
 	event: ContentBlockDeltaEvent,
 	blocks: Block[],
+	contentIndexByBlockIndex: Map<number, number>,
 	output: AssistantMessage,
 	stream: AssistantMessageEventStream,
 ): void {
 	const contentBlockIndex = event.contentBlockIndex;
 	const delta = event.delta;
-	let index = blocks.findIndex(b => b[kStreamingBlockIndex] === contentBlockIndex);
+	let index = contentIndexByBlockIndex.get(contentBlockIndex) ?? -1;
 	let block = blocks[index];
 
 	if (delta?.text !== undefined) {
 		// If no text block exists yet, create one — `handleContentBlockStart` is not sent for text blocks
 		if (!block) {
 			const newBlock: Block = { type: "text", text: "", [kStreamingBlockIndex]: contentBlockIndex };
-			output.content.push(newBlock);
-			index = blocks.length - 1;
-			block = blocks[index];
+			index = pushStreamBlock(blocks, contentIndexByBlockIndex, newBlock, contentBlockIndex);
+			block = newBlock;
 			stream.push({ type: "text_start", contentIndex: index, partial: output });
 		}
 		if (block.type === "text") {
@@ -863,9 +902,8 @@ function handleContentBlockDelta(
 				thinkingSignature: "",
 				[kStreamingBlockIndex]: contentBlockIndex,
 			};
-			output.content.push(newBlock);
-			thinkingIndex = blocks.length - 1;
-			thinkingBlock = blocks[thinkingIndex];
+			thinkingIndex = pushStreamBlock(blocks, contentIndexByBlockIndex, newBlock, contentBlockIndex);
+			thinkingBlock = newBlock;
 			stream.push({ type: "thinking_start", contentIndex: thinkingIndex, partial: output });
 		}
 
@@ -901,10 +939,11 @@ function handleMetadata(event: MetadataEvent, model: Model<"bedrock-converse-str
 function handleContentBlockStop(
 	event: ContentBlockStopEvent,
 	blocks: Block[],
+	contentIndexByBlockIndex: Map<number, number>,
 	output: AssistantMessage,
 	stream: AssistantMessageEventStream,
 ): void {
-	const index = blocks.findIndex(b => b[kStreamingBlockIndex] === event.contentBlockIndex);
+	const index = contentIndexByBlockIndex.get(event.contentBlockIndex) ?? -1;
 	const block = blocks[index];
 	if (!block) return;
 

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). */