@oh-my-pi/pi-ai 16.2.1 → 16.2.2

package/src/providers/anthropic-messages-server.ts

@@ -1,6 +1,7 @@
 import { logger } from "@oh-my-pi/pi-utils";
 import { type } from "arktype";
 import { captureRequestHeaders, resolvePromptCacheKey } from "../auth-gateway/http";
+import * as AIError from "../error";
 import type {
 	AssistantMessage,
 	AssistantMessageEventStream,
@@ -293,7 +294,7 @@ function deriveCacheRetention(data: {
 export function parseRequest(body: unknown, headers?: Headers): ParsedRequest {
 	const data = anthropicMessagesRequestSchema(body);
 	if (data instanceof type.errors) {
-		throw new Error(`anthropic-messages: ${data.summary}`);
+		throw new AIError.ValidationError(`anthropic-messages: ${data.summary}`);
 	}
 
 	const now = Date.now();
@@ -457,7 +458,13 @@ function encodeUsage(message: AssistantMessage): Record<string, unknown> {
 
 export function encodeResponse(message: AssistantMessage, requestedModelId: string): Record<string, unknown> {
 	if (message.stopReason === "error" || message.stopReason === "aborted") {
-		throw new Error(message.errorMessage ?? `anthropic-messages: upstream ${message.stopReason}`);
+		throw new AIError.ProviderResponseError(
+			message.errorMessage ?? `anthropic-messages: upstream ${message.stopReason}`,
+			{
+				provider: "anthropic",
+				kind: "output",
+			},
+		);
 	}
 	return {
 		id: message.responseId ?? newMessageId(),

package/src/providers/anthropic.ts

@@ -9,17 +9,15 @@ import { isAnthropicOAuthToken } from "@oh-my-pi/pi-catalog/utils";
 import { parseGitHubCopilotApiKey } from "@oh-my-pi/pi-catalog/wire/github-copilot";
 import {
 	$env,
-	extractHttpStatusFromError,
 	getInstallId,
 	isEnoent,
-	isRetryableError,
-	isUnexpectedSocketCloseMessage,
 	logger,
 	parseJsonWithRepair,
 	parseStreamingJsonThrottled,
 	readSseEvents,
 } from "@oh-my-pi/pi-utils";
-import { isUsageLimitError } from "../rate-limit-utils";
+import { renderDemotedThinking } from "../dialect/demotion";
+import * as AIError from "../error";
 import { getEnvApiKey, OUTPUT_FALLBACK_BUFFER } from "../stream";
 import type {
 	Api,
@@ -48,13 +46,18 @@ import type {
 import { resolveServiceTier } from "../types";
 import { isRecord, normalizeSystemPrompts, normalizeToolCallId, resolveCacheRetention } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
+import {
+	clearStreamingPartialJson,
+	kStreamingBlockIndex,
+	kStreamingLastParseLen,
+	kStreamingPartialJson,
+} from "../utils/block-symbols";
 import { withEmptyCompletionRetry } from "../utils/empty-completion-retry";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { isFoundryEnabled } from "../utils/foundry";
-import { finalizeErrorMessage, type RawHttpRequestDump, rewriteCopilotError } from "../utils/http-inspector";
+import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
 import { getStreamFirstEventTimeoutMs, getStreamIdleTimeoutMs, iterateWithIdleTimeout } from "../utils/idle-iterator";
 import { notifyProviderResponse } from "../utils/provider-response";
-import { isCopilotTransientModelError } from "../utils/retry";
 import { COMBINATOR_KEYS, NO_STRICT, toolWireSchema } from "../utils/schema";
 import { spillToDescription } from "../utils/schema/spill";
 import { createSdkStreamRequestOptions } from "../utils/sdk-stream-timeout";
@@ -384,38 +387,6 @@ export function clearAnthropicFastModeFallback(
 	}
 }
 
-function isAnthropicStrictGrammarTooLargeError(error: unknown): boolean {
-	if (extractHttpStatusFromError(error) !== 400) return false;
-	const message = error instanceof Error ? error.message : String(error);
-	const isStrictGrammarTooLarge = /compiled grammar/i.test(message) && /too large/i.test(message);
-	const isSchemaCompilationTooComplex =
-		/schema/i.test(message) && /too complex/i.test(message) && /compil/i.test(message);
-	return /invalid_request_error/i.test(message) && (isStrictGrammarTooLarge || isSchemaCompilationTooComplex);
-}
-
-export function isAnthropicFastModeUnsupportedError(error: unknown): boolean {
-	const status = extractHttpStatusFromError(error);
-	if (status !== 400 && status !== 429) return false;
-	const message = error instanceof Error ? error.message : String(error);
-	// 400 invalid_request_error — model doesn't accept `speed` at all.
-	// Observed: "'claude-opus-4-5-20251101' does not support the `speed` parameter."
-	// Stay tolerant of phrasing drift ("is not supported", quoted vs backticked field).
-	if (
-		status === 400 &&
-		/invalid_request_error/i.test(message) &&
-		/\bspeed\b/i.test(message) &&
-		/not support/i.test(message)
-	) {
-		return true;
-	}
-	// 429 rate_limit_error — account lacks the extra-usage entitlement fast mode requires.
-	// Observed: "Extra usage is required for fast mode."
-	if (status === 429 && /rate_limit_error/i.test(message) && /fast mode/i.test(message)) {
-		return true;
-	}
-	return false;
-}
-
 function hasStrictAnthropicTools(params: MessageCreateParamsStreaming): boolean {
 	return params.tools?.some(tool => tool.strict === true) ?? false;
 }
@@ -1228,7 +1199,7 @@ function resolvePemValue(value: string | undefined, name: string): string | unde
 			return fs.readFileSync(trimmed, "utf8");
 		} catch (error) {
 			if (isEnoent(error)) {
-				throw new Error(`${name} path does not exist: ${trimmed}`);
+				throw new AIError.ValidationError(`${name} path does not exist: ${trimmed}`);
 			}
 			throw error;
 		}
@@ -1249,7 +1220,9 @@ function resolveFoundryTlsOptions(model: Model<"anthropic-messages">): FoundryTl
 	const key = resolvePemValue($env.CLAUDE_CODE_CLIENT_KEY, "CLAUDE_CODE_CLIENT_KEY");
 
 	if ((cert && !key) || (!cert && key)) {
-		throw new Error("Both CLAUDE_CODE_CLIENT_CERT and CLAUDE_CODE_CLIENT_KEY must be set for mTLS.");
+		throw new AIError.ConfigurationError(
+			"Both CLAUDE_CODE_CLIENT_CERT and CLAUDE_CODE_CLIENT_KEY must be set for mTLS.",
+		);
 	}
 
 	const options: FoundryTlsOptions = {};
@@ -1339,14 +1312,15 @@ function createAnthropicSseStreamError(data: string): Error {
 		const errorType = typeof parsed?.error?.type === "string" ? parsed.error.type : undefined;
 		const message = typeof parsed?.error?.message === "string" ? parsed.error.message : undefined;
 		if (message) {
-			return new Error(
+			return new AIError.ProviderResponseError(
 				errorType ? `Anthropic stream error (${errorType}): ${message}` : `Anthropic stream error: ${message}`,
+				{ provider: "anthropic", kind: "output" },
 			);
 		}
 	} catch {
 		// Not a JSON envelope; fall through to the raw payload.
 	}
-	return new Error(data);
+	return new AIError.ProviderResponseError(data, { provider: "anthropic", kind: "output" });
 }
 
 async function* iterateAnthropicEvents(
@@ -1355,7 +1329,7 @@ async function* iterateAnthropicEvents(
 	onSseEvent?: AnthropicOptions["onSseEvent"],
 ): AsyncGenerator<AnthropicStreamEvent> {
 	if (!response.body) {
-		throw new Error("Attempted to iterate over an Anthropic response with no body");
+		throw new AIError.AnthropicStreamEnvelopeError("Attempted to iterate over an Anthropic response with no body");
 	}
 
 	let sawMessageStart = false;
@@ -1444,7 +1418,7 @@ async function getAnthropicStreamResponse(
 		const { data, response, request_id } = await request.withResponse();
 		return { events: data, response, requestId: request_id, recordsRawSseEvents: false };
 	}
-	throw new Error("Anthropic SDK request did not expose a stream response");
+	throw new AIError.AnthropicStreamEnvelopeError("Anthropic SDK request did not expose a stream response");
 }
 
 async function* observeDecodedAnthropicSdkEvents(
@@ -1461,23 +1435,9 @@ async function* observeDecodedAnthropicSdkEvents(
 
 const PROVIDER_MAX_RETRIES = 10;
 
-/** Transient stream corruption errors where the response was truncated mid-JSON. */
-function isTransientStreamParseError(error: unknown): boolean {
-	if (!(error instanceof Error)) return false;
-	return /unterminated string|unexpected end of json input|unexpected end of data|unexpected eof|end of file|eof while parsing|truncated/i.test(
-		error.message,
-	);
-}
-
-const ANTHROPIC_STREAM_ENVELOPE_ERROR_PREFIX = "Anthropic stream envelope error:";
-
-function createAnthropicStreamEnvelopeError(message: string): Error {
-	return new Error(`${ANTHROPIC_STREAM_ENVELOPE_ERROR_PREFIX} ${message}`);
-}
-
 /**
  * Log a malformed-stream-envelope anomaly without aborting the turn. The strict
- * parser would `throw createAnthropicStreamEnvelopeError(...)` here; we instead
+ * parser would `throw new AnthropicStreamEnvelopeError(...)` here; we instead
  * surface a warning and let the caller skip the offending event (or finalize what
  * already streamed) so a non-conforming endpoint degrades to best-effort content
  * rather than failing the request.
@@ -1492,49 +1452,18 @@ function shouldIgnoreAnthropicPreambleEvent(eventType: unknown): boolean {
 	return !ANTHROPIC_MESSAGE_EVENTS.has(eventType);
 }
 
-function isTransientStreamEnvelopeError(error: unknown): boolean {
-	if (!(error instanceof Error)) return false;
-	return (
-		error.message.includes(ANTHROPIC_STREAM_ENVELOPE_ERROR_PREFIX) ||
-		/stream event order|before message_start/i.test(error.message)
-	);
-}
-
-function isProviderRetryableStreamEnvelopeError(error: unknown): boolean {
-	if (!(error instanceof Error)) return false;
-	return /stream event order|before message_start/i.test(error.message);
-}
-
-function isAnthropicTransientTransportMessage(message: string): boolean {
-	return message.includes("tls: bad record mac") || message.includes("type=server_error");
-}
-
+/**
+ * Whether an Anthropic (or Copilot-over-Anthropic) stream error should be
+ * retried. The classification lives in {@link AIError.isProviderRetryableError};
+ * this wrapper injects the Copilot-specific `model_not_supported` transient
+ * check, which the error module must not import directly.
+ */
 export function isProviderRetryableError(error: unknown, provider?: string): boolean {
-	if (!(error instanceof Error)) return false;
-	if (provider === "github-copilot" && isCopilotTransientModelError(error)) return true;
-	// Account-level usage/quota limits ("usage_limit_reached", "exceed your
-	// account's rate limit", "quota exceeded") are persistent — the server
-	// parks the credential for minutes-to-hours (see the long `retry-after`).
-	// Retrying the same key with the provider's seconds-scale backoff never
-	// helps; these are owned by the credential-rotation layer (auth-gateway /
-	// `streamSimple` a/b/c policy), so surface them immediately instead of
-	// burning the retry budget here.
-	if (isUsageLimitError(error.message)) return false;
-	const status = extractHttpStatusFromError(error);
-	if (status !== undefined && status >= 400 && status < 500 && status !== 408 && status !== 429) return false;
-	const msg = error.message.toLowerCase();
-	if (
-		isUnexpectedSocketCloseMessage(msg) ||
-		isAnthropicTransientTransportMessage(msg) ||
-		/rate.?limit|too many requests|overloaded|service.?unavailable|internal_error|server_error|bad record mac|stream error.*received from peer|1302|timed?\s*out while waiting for the first event|timeout waiting for first/i.test(
-			msg,
-		) ||
-		isTransientStreamParseError(error) ||
-		isProviderRetryableStreamEnvelopeError(error)
-	) {
-		return true;
-	}
-	return isRetryableError(error);
+	return AIError.isProviderRetryableError(error, {
+		provider,
+		isProviderTransient:
+			provider === "github-copilot" ? (err): boolean => AIError.isCopilotTransientModelError(err) : undefined,
+	});
 }
 
 const THINKING_ENVELOPE_OPEN = "<thinking>";
@@ -1609,7 +1538,7 @@ const streamAnthropicOnce = (
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
-		const startTime = Date.now();
+		const startTime = performance.now();
 		let firstTokenTime: number | undefined;
 
 		const output: AssistantMessage = {
@@ -1772,15 +1701,14 @@ const streamAnthropicOnce = (
 				| ThinkingContent
 				| RedactedThinkingContent
 				| TextContent
-				| (ToolCall & { partialJson: string; lastParseLen?: number })
-			) & { index: number };
+				| (ToolCall & { [kStreamingPartialJson]: string; [kStreamingLastParseLen]?: number })
+			) & { [kStreamingBlockIndex]: number };
 			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getStreamIdleTimeoutMs();
 			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs);
 			const requestTimeoutMs =
 				firstEventTimeoutMs !== undefined && firstEventTimeoutMs > 0 ? firstEventTimeoutMs : undefined;
 			const blocks = output.content as Block[];
 			const finalizeStreamBlock = (block: Block, contentIndex: number): void => {
-				delete (block as { index?: number }).index;
 				if (block.type === "text") {
 					stream.push({ type: "text_end", contentIndex, content: block.text, partial: output });
 				} else if (block.type === "thinking") {
@@ -1792,7 +1720,9 @@ const streamAnthropicOnce = (
 					stream.push({ type: "thinking_end", contentIndex, content: block.thinking, partial: output });
 				} else if (block.type === "toolCall") {
 					const finalJson =
-						block.partialJson.length > 0 ? block.partialJson : JSON.stringify(block.arguments ?? {});
+						block[kStreamingPartialJson].length > 0
+							? block[kStreamingPartialJson]
+							: JSON.stringify(block.arguments ?? {});
 					try {
 						block.arguments = parseJsonWithRepair(finalJson) as ToolCall["arguments"];
 					} catch (parseError) {
@@ -1814,8 +1744,7 @@ const streamAnthropicOnce = (
 							};
 						}
 					}
-					delete (block as { partialJson?: string }).partialJson;
-					delete (block as { lastParseLen?: number }).lastParseLen;
+					clearStreamingPartialJson(block);
 					stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial: output });
 				}
 			};
@@ -1824,8 +1753,12 @@ const streamAnthropicOnce = (
 			// Provider-level transport/rate-limit failures: only before any streamed content starts.
 			// Malformed envelopes/JSON: only before replay-unsafe text/tool events are visible on this stream.
 			let providerRetryAttempt = 0;
-			const firstEventTimeoutAbortError = new Error("Anthropic stream timed out while waiting for the first event");
-			const idleTimeoutAbortError = new Error("Anthropic stream stalled while waiting for the next event");
+			const firstEventTimeoutAbortError = new AIError.StreamTimeoutError(
+				"Anthropic stream timed out while waiting for the first event",
+			);
+			const idleTimeoutAbortError = new AIError.StreamTimeoutError(
+				"Anthropic stream stalled while waiting for the next event",
+			);
 			while (true) {
 				activeAbortTracker = createAbortSourceTracker(options?.signal);
 				const { requestSignal } = activeAbortTracker;
@@ -1945,7 +1878,7 @@ const streamAnthropicOnce = (
 							if (shouldIgnoreAnthropicPreambleEvent(event.type)) {
 								continue;
 							}
-							throw createAnthropicStreamEnvelopeError(`received ${event.type} before message_start`);
+							throw new AIError.AnthropicStreamEnvelopeError(`received ${event.type} before message_start`);
 						}
 
 						if (event.type === "content_block_start") {
@@ -1971,13 +1904,13 @@ const streamAnthropicOnce = (
 								reportAnthropicEnvelopeAnomaly("content_block_start missing content_block payload");
 								continue;
 							}
-							if (!firstTokenTime) firstTokenTime = Date.now();
+							if (!firstTokenTime) firstTokenTime = performance.now();
 							if (event.content_block.type === "text") {
 								streamedReplayUnsafeContent = true;
 								const block: Block = {
 									type: "text",
 									text: "",
-									index: event.index,
+									[kStreamingBlockIndex]: event.index,
 								};
 								output.content.push(block);
 								const contentIndex = output.content.length - 1;
@@ -1993,7 +1926,7 @@ const streamAnthropicOnce = (
 									type: "thinking",
 									thinking: "",
 									thinkingSignature: "",
-									index: event.index,
+									[kStreamingBlockIndex]: event.index,
 								};
 								output.content.push(block);
 								const contentIndex = output.content.length - 1;
@@ -2008,7 +1941,7 @@ const streamAnthropicOnce = (
 								const block: Block = {
 									type: "redactedThinking",
 									data: event.content_block.data,
-									index: event.index,
+									[kStreamingBlockIndex]: event.index,
 								};
 								output.content.push(block);
 								openBlocks.set(event.index, {
@@ -2026,8 +1959,8 @@ const streamAnthropicOnce = (
 										model.compat.escapeBuiltinToolNames,
 									),
 									arguments: event.content_block.input ?? {},
-									partialJson: "",
-									index: event.index,
+									[kStreamingPartialJson]: "",
+									[kStreamingBlockIndex]: event.index,
 								};
 								output.content.push(block);
 								const contentIndex = output.content.length - 1;
@@ -2090,11 +2023,14 @@ const streamAnthropicOnce = (
 									continue;
 								}
 								streamedReplayUnsafeContent = true;
-								block.partialJson += event.delta.partial_json;
-								const throttled = parseStreamingJsonThrottled(block.partialJson, block.lastParseLen ?? 0);
+								block[kStreamingPartialJson] += event.delta.partial_json;
+								const throttled = parseStreamingJsonThrottled(
+									block[kStreamingPartialJson],
+									block[kStreamingLastParseLen] ?? 0,
+								);
 								if (throttled) {
 									block.arguments = throttled.value;
-									block.lastParseLen = throttled.parsedLen;
+									block[kStreamingLastParseLen] = throttled.parsedLen;
 								}
 								stream.push({
 									type: "toolcall_delta",
@@ -2197,10 +2133,10 @@ const streamAnthropicOnce = (
 						throw firstEventTimeoutError;
 					}
 					if (activeAbortTracker.wasCallerAbort()) {
-						throw new Error("Request was aborted");
+						throw new AIError.AbortError();
 					}
 					if (!sawEvent || !sawMessageStart) {
-						throw createAnthropicStreamEnvelopeError("stream ended before message_start");
+						throw new AIError.AnthropicStreamEnvelopeError("stream ended before message_start");
 					}
 					if (!sawMessageStop) {
 						reportAnthropicEnvelopeAnomaly("stream ended before message_stop");
@@ -2218,7 +2154,10 @@ const streamAnthropicOnce = (
 					}
 
 					if (output.stopReason === "aborted" || output.stopReason === "error") {
-						throw new Error(output.errorMessage ?? "An unknown error occurred");
+						throw new AIError.ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
+							provider: model.provider,
+							kind: "output",
+						});
 					}
 					break;
 				} catch (streamError) {
@@ -2227,7 +2166,7 @@ const streamAnthropicOnce = (
 						!disableStrictTools &&
 						firstTokenTime === undefined &&
 						hasStrictAnthropicTools(params) &&
-						isAnthropicStrictGrammarTooLargeError(streamFailure)
+						AIError.isGrammarError(streamFailure)
 					) {
 						// Log-only: the retried turn must not carry an errorMessage on
 						// success (consumers treat its presence as failure).
@@ -2254,7 +2193,7 @@ const streamAnthropicOnce = (
 						!dropFastMode &&
 						resolveServiceTier(options?.serviceTier, model.provider) === "priority" &&
 						firstTokenTime === undefined &&
-						isAnthropicFastModeUnsupportedError(streamFailure)
+						AIError.isFastModeUnsupported(streamFailure)
 					) {
 						logger.debug("anthropic: fast mode unsupported, retrying without speed", {
 							model: model.id,
@@ -2276,7 +2215,7 @@ const streamAnthropicOnce = (
 						continue;
 					}
 					const isTransientEnvelopeFailure =
-						isTransientStreamParseError(streamFailure) || isTransientStreamEnvelopeError(streamFailure);
+						AIError.isTransientStreamParseError(streamFailure) || AIError.isStreamEnvelopeError(streamFailure);
 					const isLocalIdleTimeout =
 						streamFailure === idleTimeoutAbortError ||
 						(streamFailure instanceof Error && streamFailure.message === idleTimeoutAbortError.message);
@@ -2299,7 +2238,9 @@ const streamAnthropicOnce = (
 					// 429/529-style failures: retrying sooner than the server asked is a
 					// guaranteed failure that just burns the retry budget.
 					const headerDelayMs =
-						streamFailure instanceof AnthropicApiError ? retryDelayFromHeaders(streamFailure.headers) : undefined;
+						streamFailure instanceof Error && streamFailure instanceof AnthropicApiError
+							? retryDelayFromHeaders(streamFailure.headers)
+							: undefined;
 					const delayMs = headerDelayMs !== undefined ? Math.max(headerDelayMs, backoffDelayMs) : backoffDelayMs;
 					if (options?.providerRetryWait) {
 						await options.providerRetryWait(delayMs, options.signal);
@@ -2316,7 +2257,7 @@ const streamAnthropicOnce = (
 					firstTokenTime = undefined;
 				}
 			}
-			output.duration = Date.now() - startTime;
+			output.duration = performance.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			if (dropFastMode && resolveServiceTier(options?.serviceTier, model.provider) === "priority") {
 				output.disabledFeatures = [...(output.disabledFeatures ?? []), "priority"];
@@ -2325,23 +2266,19 @@ const streamAnthropicOnce = (
 			stream.end();
 		} catch (error) {
 			for (const block of output.content) {
-				delete (block as { index?: number }).index;
-				delete (block as { partialJson?: string }).partialJson;
-				delete (block as { lastParseLen?: number }).lastParseLen;
+				if (block.type === "toolCall") clearStreamingPartialJson(block);
 			}
-			const firstEventTimeoutError = activeAbortTracker.getLocalAbortReason();
-			output.stopReason = activeAbortTracker.wasCallerAbort() ? "aborted" : "error";
-			output.errorStatus = extractHttpStatusFromError(error);
-			try {
-				output.errorMessage =
-					firstEventTimeoutError?.message ?? (await finalizeErrorMessage(error, rawRequestDump));
-				output.errorMessage = rewriteCopilotError(output.errorMessage, error, model.provider);
-			} catch {
-				// finalizeErrorMessage must never take the stream down with it — a
-				// throw here would skip stream.end() and hang result() forever.
-				output.errorMessage = error instanceof Error ? error.message : String(error);
-			}
-			output.duration = Date.now() - startTime;
+			const result = await AIError.finalize(error, {
+				api: model.api,
+				provider: model.provider,
+				abortTracker: activeAbortTracker,
+				rawRequestDump,
+			});
+			output.stopReason = result.stopReason;
+			output.errorStatus = result.status;
+			output.errorId = result.id;
+			output.errorMessage = result.message;
+			output.duration = performance.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "error", reason: output.stopReason, error: output });
 			stream.end();
@@ -2631,7 +2568,7 @@ function ensureMaxTokensForThinking(params: MessageCreateParamsStreaming, maxAll
 
 	const clampedBudget = raisedMaxTokens - OUTPUT_FALLBACK_BUFFER;
 	if (clampedBudget <= 0) {
-		throw new Error(
+		throw new AIError.ConfigurationError(
 			`Anthropic thinking budget requires max_tokens greater than ${OUTPUT_FALLBACK_BUFFER}; got ${raisedMaxTokens}`,
 		);
 	}
@@ -3238,7 +3175,7 @@ export function convertAnthropicMessages(
 							if (block.thinking.trim().length === 0) continue;
 							blocks.push({
 								type: "text",
-								text: block.thinking.toWellFormed(),
+								text: renderDemotedThinking(model.id, block.thinking),
 							});
 							continue;
 						}
@@ -3260,7 +3197,7 @@ export function convertAnthropicMessages(
 						} else {
 							blocks.push({
 								type: "text",
-								text: block.thinking.toWellFormed(),
+								text: renderDemotedThinking(model.id, block.thinking),
 							});
 						}
 					} else {

package/src/providers/aws-credentials.ts

@@ -23,6 +23,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { $env, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import * as AIError from "../error";
 import type { FetchImpl } from "../types";
 import { raceWithSignal } from "../utils/abort";
 import type { AwsCredentials } from "./aws-sigv4";
@@ -111,9 +112,10 @@ async function resolveFresh(
 		if (imdsCreds) return imdsCreds;
 	}
 
-	throw new Error(
+	throw new AIError.AwsCredentialsError(
 		`Unable to resolve AWS credentials. Set AWS_ACCESS_KEY_ID+AWS_SECRET_ACCESS_KEY, ` +
 			`or configure profile '${profile}' in ~/.aws/credentials (or ~/.aws/config for SSO).`,
+		"resolution",
 	);
 }
 
@@ -245,11 +247,17 @@ async function readSsoCredentials(
 
 	const token = await loadSsoCachedToken(startUrl, sessionName);
 	if (!token?.accessToken) {
-		throw new Error(`AWS SSO token for ${startUrl} not found in ~/.aws/sso/cache. Run 'aws sso login' first.`);
+		throw new AIError.AwsCredentialsError(
+			`AWS SSO token for ${startUrl} not found in ~/.aws/sso/cache. Run 'aws sso login' first.`,
+			"sso-token-missing",
+		);
 	}
 	const expiresAt = token.expiresAt ? Date.parse(token.expiresAt) : Number.POSITIVE_INFINITY;
 	if (Number.isFinite(expiresAt) && expiresAt <= Date.now()) {
-		throw new Error(`AWS SSO token for ${startUrl} has expired. Run 'aws sso login' to refresh.`);
+		throw new AIError.AwsCredentialsError(
+			`AWS SSO token for ${startUrl} has expired. Run 'aws sso login' to refresh.`,
+			"sso-token-expired",
+		);
 	}
 
 	const url =
@@ -263,13 +271,20 @@ async function readSsoCredentials(
 	});
 	if (!response.ok) {
 		const body = await response.text().catch(() => "");
-		throw new Error(`AWS SSO GetRoleCredentials failed: ${response.status} ${body.slice(0, 200)}`);
+		throw new AIError.AwsCredentialsError(
+			`AWS SSO GetRoleCredentials failed: ${response.status} ${body.slice(0, 200)}`,
+			"sso-role",
+		);
 	}
 	const json = (await response.json()) as {
 		roleCredentials?: { accessKeyId: string; secretAccessKey: string; sessionToken: string; expiration: number };
 	};
 	const role = json.roleCredentials;
-	if (!role) throw new Error("AWS SSO GetRoleCredentials: missing roleCredentials in response");
+	if (!role)
+		throw new AIError.AwsCredentialsError(
+			"AWS SSO GetRoleCredentials: missing roleCredentials in response",
+			"sso-role",
+		);
 
 	// region is honored at the caller; we only consume defaultRegion to keep the
 	// param wired for symmetry with other resolution paths.
@@ -359,23 +374,32 @@ async function readCredentialProcess(
 	]);
 	if (exitCode !== 0) {
 		const tail = stderr.trim().slice(-512) || stdout.trim().slice(-512) || "(no output)";
-		throw new Error(`AWS credential_process for profile '${profile}' exited ${exitCode}: ${tail}`);
+		throw new AIError.AwsCredentialsError(
+			`AWS credential_process for profile '${profile}' exited ${exitCode}: ${tail}`,
+			"credential-process",
+		);
 	}
 
 	let parsed: CredentialProcessEnvelope;
 	try {
 		parsed = JSON.parse(stdout) as CredentialProcessEnvelope;
 	} catch (err) {
-		throw new Error(`AWS credential_process for profile '${profile}' did not emit valid JSON: ${String(err)}`);
+		throw new AIError.AwsCredentialsError(
+			`AWS credential_process for profile '${profile}' did not emit valid JSON: ${String(err)}`,
+			"credential-process",
+			{ cause: err },
+		);
 	}
 	if (parsed.Version !== 1) {
-		throw new Error(
+		throw new AIError.AwsCredentialsError(
 			`AWS credential_process for profile '${profile}' returned unsupported Version ${parsed.Version ?? "<missing>"}; expected 1.`,
+			"credential-process",
 		);
 	}
 	if (!parsed.AccessKeyId || !parsed.SecretAccessKey) {
-		throw new Error(
+		throw new AIError.AwsCredentialsError(
 			`AWS credential_process for profile '${profile}' returned envelope without AccessKeyId/SecretAccessKey.`,
+			"credential-process",
 		);
 	}
 
@@ -397,7 +421,10 @@ async function readCredentialProcess(
 function buildCredentialProcessArgv(profile: string, command: string): string[] {
 	const tokens = tokenizeCredentialProcessCommand(command);
 	if (tokens.length === 0) {
-		throw new Error(`AWS credential_process for profile '${profile}' is empty.`);
+		throw new AIError.AwsCredentialsError(
+			`AWS credential_process for profile '${profile}' is empty.`,
+			"credential-process",
+		);
 	}
 	if (process.platform === "win32" && isBatchScript(tokens[0])) {
 		return ["cmd.exe", "/d", "/s", "/c", command];
@@ -479,7 +506,10 @@ export function tokenizeCredentialProcessCommand(cmd: string): string[] {
 		current += ch;
 	}
 	if (mode !== "normal") {
-		throw new Error("AWS credential_process command has an unterminated quote.");
+		throw new AIError.AwsCredentialsError(
+			"AWS credential_process command has an unterminated quote.",
+			"credential-process",
+		);
 	}
 	if (hasToken) tokens.push(current);
 	return tokens;