@oh-my-pi/pi-ai 15.5.15 → 15.6.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [15.6.0] - 2026-05-30
+
+### Fixed
+
+- Fixed Anthropic adaptive-thinking replay preserving signed thinking blocks on the latest abandoned tool-use assistant message, avoiding `thinking blocks in the latest assistant message cannot be modified` 400s. ([#1531](https://github.com/can1357/oh-my-pi/issues/1531))
+
 ## [15.5.15] - 2026-05-30
 
 ### Added

package/dist/types/model-thinking.d.ts

@@ -91,3 +91,10 @@ export declare function hasOpus47ApiRestrictions(modelId: string): boolean;
  * @see https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages
  */
 export declare function supportsMidConversationSystemMessages(modelId: string): boolean;
+/**
+ * Claude Opus 4.8 must emit at most one tool call per turn: the Anthropic
+ * Messages provider sends `tool_choice.disable_parallel_tool_use = true` for
+ * this model. Scoped to exactly 4.8 — earlier and later Opus versions keep
+ * Anthropic's default parallel tool-calling.
+ */
+export declare function disablesParallelToolUse(modelId: string): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "15.5.15",
+	"version": "15.6.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,10 +38,10 @@
 		"generate-models": "bun scripts/generate-models.ts"
 	},
 	"dependencies": {
-		"@anthropic-ai/sdk": "^0.94.0",
+		"@anthropic-ai/sdk": "^0.99.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-utils": "15.5.15",
-		"openai": "^6.36.0",
+		"@oh-my-pi/pi-utils": "15.6.0",
+		"openai": "^6.39.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"
 	},

package/src/auth-broker/remote-store.ts

@@ -281,7 +281,7 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 
 	async prepareForRequest(credentialId: number, opts: { signal?: AbortSignal } = {}): Promise<boolean> {
 		const entry = this.#snapshot.credentials.find(candidate => candidate.id === credentialId);
-		if (!entry || entry.credential.type !== "oauth" || entry.rotatesInMs === null) return false;
+		if (entry?.credential.type !== "oauth" || entry.rotatesInMs === null) return false;
 		const remainingMs = this.#snapshotReceivedAt + entry.rotatesInMs - Date.now();
 		if (remainingMs > WAIT_THRESHOLD_MS) return false;
 		return this.waitForFreshSnapshot(MAX_WAIT_MS, opts);

package/src/auth-storage.ts

@@ -2984,7 +2984,7 @@ export class AuthStorage {
 		if (!prepare) return true;
 		const stored = this.#getStoredCredentials(provider);
 		const selected = stored[selection.index];
-		if (!selected || selected.credential.type !== "oauth") return false;
+		if (selected?.credential.type !== "oauth") return false;
 
 		const prepared = await prepare(selected.id, { signal: options?.signal });
 		if (!prepared) return true;
@@ -2996,7 +2996,7 @@ export class AuthStorage {
 		const latestIndex = latestRows.findIndex(row => row.id === selected.id);
 		if (latestIndex === -1) return false;
 		const latest = latestRows[latestIndex];
-		if (!latest || latest.credential.type !== "oauth") return false;
+		if (latest?.credential.type !== "oauth") return false;
 		selection.index = latestIndex;
 		selection.credential = latest.credential;
 		return true;

package/src/model-thinking.ts

@@ -379,6 +379,18 @@ export function supportsMidConversationSystemMessages(modelId: string): boolean
 	return parsed.kind === "opus" && semverGte(parsed.version, "4.8");
 }
 
+/**
+ * Claude Opus 4.8 must emit at most one tool call per turn: the Anthropic
+ * Messages provider sends `tool_choice.disable_parallel_tool_use = true` for
+ * this model. Scoped to exactly 4.8 — earlier and later Opus versions keep
+ * Anthropic's default parallel tool-calling.
+ */
+export function disablesParallelToolUse(modelId: string): boolean {
+	const parsed = parseAnthropicModel(getCanonicalModelId(modelId));
+	if (!parsed) return false;
+	return parsed.kind === "opus" && semverEqual(parsed.version, "4.8");
+}
+
 function anthropicModelHasRealXHighEffort<TApi extends Api>(model: ApiModel<TApi>): boolean {
 	if (model.api !== "anthropic-messages") return false;
 	const parsedModel = parseKnownModel(model.id);

package/src/provider-models/openai-compat.ts

@@ -2147,25 +2147,23 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 						const reference = resolveReference(defaults.id);
 						const copilotLimits = extractCopilotLimits(entry);
 						// Copilot exposes token limits under capabilities.limits.*.
-						// max_prompt_tokens is the prompt capacity (what OMP calls contextWindow).
-						// max_context_window_tokens is the total window (prompt + output budget)
-						// and must NOT be used for contextWindow — it inflates the limit and
-						// breaks compaction thresholds, overflow detection, and promotion.
-						// The OpenAI-compatible root-level `context_length` field mirrors the
-						// total window (e.g. 400k for gpt-5.4), so Copilot's max_prompt_tokens
-						// (the true prompt budget) must take precedence whenever it is present.
-						const contextWindowFallback = toPositiveNumber(
-							entry.context_length,
-							reference?.contextWindow ?? defaults.contextWindow,
-						);
+						// max_context_window_tokens is the model's total usable window;
+						// max_prompt_tokens is Copilot's prompt/summarization budget and
+						// must only be a fallback when total-window fields are absent.
 						const contextWindow = toPositiveNumber(
-							copilotLimits.maxPromptTokens,
-							reference ? Math.min(contextWindowFallback, reference.contextWindow) : contextWindowFallback,
+							copilotLimits.maxContextWindowTokens,
+							toPositiveNumber(
+								entry.context_length,
+								toPositiveNumber(
+									copilotLimits.maxPromptTokens,
+									reference?.contextWindow ?? defaults.contextWindow,
+								),
+							),
 						);
 						const maxTokens = toPositiveNumber(
-							entry.max_completion_tokens,
+							copilotLimits.maxOutputTokens,
 							toPositiveNumber(
-								copilotLimits.maxOutputTokens,
+								entry.max_completion_tokens,
 								toPositiveNumber(
 									copilotLimits.maxNonStreamingOutputTokens,
 									reference?.maxTokens ?? defaults.maxTokens,

package/src/providers/anthropic.ts

@@ -22,6 +22,7 @@ import {
 	readSseEvents,
 } from "@oh-my-pi/pi-utils";
 import {
+	disablesParallelToolUse,
 	hasOpus47ApiRestrictions,
 	mapEffortToAnthropicAdaptiveEffort,
 	supportsMidConversationSystemMessages,
@@ -1774,7 +1775,7 @@ function disableThinkingIfToolChoiceForced(params: MessageCreateParamsStreaming)
 
 function ensureMaxTokensForThinking(params: MessageCreateParamsStreaming, model: Model<"anthropic-messages">): void {
 	const thinking = params.thinking;
-	if (!thinking || thinking.type !== "enabled") return;
+	if (thinking?.type !== "enabled") return;
 
 	const budgetTokens = thinking.budget_tokens ?? 0;
 	if (budgetTokens <= 0) return;
@@ -2133,6 +2134,21 @@ function buildParams(
 		}
 	}
 
+	// Claude Opus 4.8 must emit at most one tool call per turn. Force
+	// `disable_parallel_tool_use` onto the outgoing tool_choice (synthesizing an
+	// `auto` choice when none is set). Gated on tools being present: Anthropic
+	// rejects `tool_choice` without `tools`, and parallelism is moot otherwise.
+	// `none` rejects the field, so leave it untouched. A fresh object is built
+	// rather than mutated so the caller's `options.toolChoice` is never aliased.
+	if (disablesParallelToolUse(model.id) && params.tools && params.tools.length > 0) {
+		const current = params.tool_choice;
+		if (!current) {
+			params.tool_choice = { type: "auto", disable_parallel_tool_use: true };
+		} else if (current.type !== "none") {
+			params.tool_choice = { ...current, disable_parallel_tool_use: true };
+		}
+	}
+
 	const shouldInjectClaudeCodeInstruction = isOAuthToken && !model.id.startsWith("claude-3-5-haiku");
 	const billingSystemPrompts = normalizeSystemPrompts(context.systemPrompt);
 	const billingPayload = shouldInjectClaudeCodeInstruction

package/src/providers/openai-completions.ts

@@ -586,7 +586,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				eventStream: AssistantMessageEventStream,
 				text: string,
 			): void => {
-				if (!currentBlock || currentBlock.type !== "text") {
+				if (currentBlock?.type !== "text") {
 					finishCurrentBlock(currentBlock);
 					currentBlock = { type: "text", text: "" };
 					message.content.push(currentBlock);
@@ -607,8 +607,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				signature?: string,
 			): void => {
 				if (
-					!currentBlock ||
-					currentBlock.type !== "thinking" ||
+					currentBlock?.type !== "thinking" ||
 					(signature !== undefined && currentBlock.thinkingSignature !== signature)
 				) {
 					finishCurrentBlock(currentBlock);
@@ -815,7 +814,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 							}
 
 							if (!block) {
-								if (!currentBlock || currentBlock.type !== "toolCall") {
+								if (currentBlock?.type !== "toolCall") {
 									finishCurrentBlock(currentBlock);
 								}
 								block = {

package/src/providers/openai-responses-server.ts

@@ -954,7 +954,7 @@ export function encodeStream(
 							break;
 						}
 						case "text_delta": {
-							if (!state.open || state.open.kind !== "message") break;
+							if (state.open?.kind !== "message") break;
 							const cur: OpenMessage = state.open;
 							cur.currentPartText += ev.delta;
 							emit("response.output_text.delta", {
@@ -970,7 +970,7 @@ export function encodeStream(
 							break;
 						}
 						case "text_end": {
-							if (!state.open || state.open.kind !== "message") break;
+							if (state.open?.kind !== "message") break;
 							const cur: OpenMessage = state.open;
 							const text = ev.content ?? cur.currentPartText;
 							emit("response.output_text.done", {
@@ -997,7 +997,7 @@ export function encodeStream(
 							break;
 						}
 						case "thinking_delta": {
-							if (!state.open || state.open.kind !== "reasoning") break;
+							if (state.open?.kind !== "reasoning") break;
 							const cur: OpenReasoning = state.open;
 							cur.reasoningText += ev.delta;
 							emit("response.reasoning_summary_text.delta", {
@@ -1009,7 +1009,7 @@ export function encodeStream(
 							break;
 						}
 						case "thinking_end": {
-							if (!state.open || state.open.kind !== "reasoning") break;
+							if (state.open?.kind !== "reasoning") break;
 							const cur: OpenReasoning = state.open;
 							const text = ev.content ?? cur.reasoningText;
 							cur.reasoningText = text;
@@ -1034,7 +1034,7 @@ export function encodeStream(
 							break;
 						}
 						case "toolcall_delta": {
-							if (!state.open || state.open.kind !== "function_call") break;
+							if (state.open?.kind !== "function_call") break;
 							const cur: OpenFunctionCall = state.open;
 							cur.argsText += ev.delta;
 							if (cur.customWireName) {
@@ -1053,7 +1053,7 @@ export function encodeStream(
 							break;
 						}
 						case "toolcall_end": {
-							if (!state.open || state.open.kind !== "function_call") break;
+							if (state.open?.kind !== "function_call") break;
 							const cur: OpenFunctionCall = state.open;
 							// Promote possibly-late info from the canonical ToolCall.
 							const tc = ev.toolCall;

package/src/providers/transform-messages.ts

@@ -17,6 +17,21 @@ const enum ToolCallStatus {
 	Aborted = 2,
 }
 
+function shouldDropTruncatedThinkingOnlyAssistant(msg: AssistantMessage): boolean {
+	const isTruncatedStop = msg.stopReason === "length" || msg.stopReason === "error" || msg.stopReason === "aborted";
+	return isTruncatedStop && !msg.content.some(block => block.type === "toolCall" || block.type === "text");
+}
+
+function getLatestSurvivingAssistantIndex(messages: readonly Message[]): number {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const msg = messages[index]!;
+		if (msg.role === "assistant" && !shouldDropTruncatedThinkingOnlyAssistant(msg)) {
+			return index;
+		}
+	}
+	return -1;
+}
+
 /**
  * Normalize tool call ID for cross-provider compatibility.
  * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
@@ -35,7 +50,7 @@ export function transformMessages<TApi extends Api>(
 	// Build a map of original tool call IDs to normalized IDs
 	const toolCallIdMap = new Map<string, string>();
 
-	const latestAssistantIndex = messages.findLastIndex(msg => msg.role === "assistant");
+	const latestSurvivingAssistantIndex = getLatestSurvivingAssistantIndex(messages);
 	// First pass: transform messages (thinking blocks, tool call ID normalization)
 	const transformed = messages.map((msg, index) => {
 		// User and developer messages pass through unchanged
@@ -61,34 +76,36 @@ export function transformMessages<TApi extends Api>(
 				assistantMsg.model === model.id;
 
 			const mustPreserveLatestAnthropicThinking =
-				index === latestAssistantIndex &&
+				index === latestSurvivingAssistantIndex &&
 				model.api === "anthropic-messages" &&
 				assistantMsg.api === "anthropic-messages";
 			// Aborted/errored messages may have partially-streamed thinking signatures.
 			// A partial signature is invalid and will be rejected by the API, so we must
 			// strip signatures from thinking blocks in these messages.
 			//
-			// Abandoned tool-use turns get the same treatment. When a turn carries
-			// toolCall blocks but did NOT request tool execution (stopReason !== "toolUse"
-			// — e.g. adaptive-thinking Opus emitting tool calls and then ending the turn
-			// on `end_turn`/`stop`), the agent loop pairs those calls with placeholder
-			// tool_results to keep the tool_use/tool_result contract valid. Replaying the
-			// turn's *signed* thinking in that tool_result continuation trips Anthropic's
-			// "`thinking` blocks in the latest assistant message cannot be modified" — the
-			// signature was bound to an end_turn context, not a tool-use one. Stripping it
-			// downgrades the thinking to plain text downstream, which the API accepts.
-			// Normal tool-use turns (stopReason "toolUse") never match this guard.
+			// Abandoned tool-use turns get the same treatment once they are no longer
+			// the latest assistant message. When a turn carries toolCall blocks but did
+			// NOT request tool execution (stopReason !== "toolUse" — e.g.
+			// adaptive-thinking Opus emitting tool calls and then ending the turn on
+			// `end_turn`/`stop`), the agent loop pairs those calls with placeholder
+			// tool_results to keep the tool_use/tool_result contract valid. Historical
+			// abandoned turns cannot safely replay their end_turn-bound signatures in
+			// that continuation, so stripping downgrades them to plain text downstream.
+			// Latest abandoned turns are exempt because Anthropic requires thinking
+			// blocks from its most recent response to remain byte-for-byte unmodified.
+			const invalidStopReason = assistantMsg.stopReason === "aborted" || assistantMsg.stopReason === "error";
 			const abandonedToolUse =
-				assistantMsg.stopReason !== "toolUse" && assistantMsg.content.some(b => b.type === "toolCall");
-			const hasInvalidSignatures =
-				assistantMsg.stopReason === "aborted" || assistantMsg.stopReason === "error" || abandonedToolUse;
+				!invalidStopReason &&
+				assistantMsg.stopReason !== "toolUse" &&
+				assistantMsg.content.some(b => b.type === "toolCall");
+			const hasInvalidSignatures = invalidStopReason || abandonedToolUse;
 
 			const transformedContent = assistantMsg.content.flatMap(block => {
 				if (block.type === "thinking") {
-					// Strip signature from aborted/errored messages — it's likely incomplete
+					// Strip untrustworthy signatures so the encoder can downgrade to text.
 					const sanitized =
 						hasInvalidSignatures && block.thinkingSignature ? { ...block, thinkingSignature: undefined } : block;
-					if (mustPreserveLatestAnthropicThinking) return sanitized;
+					if (mustPreserveLatestAnthropicThinking) return abandonedToolUse ? block : sanitized;
 					// For same model: keep thinking blocks with signatures (needed for replay)
 					// even if the thinking text is empty (OpenAI encrypted reasoning)
 					if (isSameModel && sanitized.thinkingSignature) return sanitized;
@@ -236,7 +253,6 @@ export function transformMessages<TApi extends Api>(
 			flushPendingAbortedToolCalls();
 
 			const assistantMsg = msg as AssistantMessage;
-			const toolCalls = assistantMsg.content.filter(b => b.type === "toolCall") as ToolCall[];
 
 			// Drop assistant turns that carry no actionable content (no `text`, no `toolCall`)
 			// AND were terminated by a truncating stop reason (`length` / `error` / `aborted`).
@@ -250,11 +266,8 @@ export function transformMessages<TApi extends Api>(
 			// `stopReason: "stop"` thinking-only messages are intentionally preserved: they
 			// represent reasoning-only assistant turns used for replay round-trips
 			// (OpenAI completions `reasoning_text`, Google signed thought parts).
-			const isTruncatedStop =
-				assistantMsg.stopReason === "length" ||
-				assistantMsg.stopReason === "error" ||
-				assistantMsg.stopReason === "aborted";
-			if (isTruncatedStop && toolCalls.length === 0 && !assistantMsg.content.some(b => b.type === "text")) {
+			const originalMsg = messages[i]!;
+			if (originalMsg.role === "assistant" && shouldDropTruncatedThinkingOnlyAssistant(originalMsg)) {
 				if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
 					// Still arm the aborted-turn note so downstream guidance fires.
 					pendingAbortedToolCalls = new Map();
@@ -263,6 +276,8 @@ export function transformMessages<TApi extends Api>(
 				continue;
 			}
 
+			const toolCalls = assistantMsg.content.filter(b => b.type === "toolCall") as ToolCall[];
+
 			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
 				// Keep the assistant message with tool calls intact. Real tool results are
 				// emitted immediately if available; otherwise synthesize aborted results