@guadskill/openclaw-proxy 2026.2.4

package/dist/pi-embedded-helpers-D6XTIi2t.js

@@ -0,0 +1,1298 @@
+import { t as createSubsystemLogger } from "./subsystem-CAq3uyo7.js";
+import { s as formatSandboxToolPolicyBlockedMessage } from "./sandbox-CudnqybF.js";
+import { o as resizeToJpeg, r as getImageMetadata } from "./routes-DW4Wu2jw.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { createHash } from "node:crypto";
+
+//#region src/auto-reply/thinking.ts
+function normalizeProviderId(provider) {
+	if (!provider) return "";
+	const normalized = provider.trim().toLowerCase();
+	if (normalized === "z.ai" || normalized === "z-ai") return "zai";
+	return normalized;
+}
+function isBinaryThinkingProvider(provider) {
+	return normalizeProviderId(provider) === "zai";
+}
+const XHIGH_MODEL_REFS = [
+	"openai/gpt-5.2",
+	"openai-codex/gpt-5.3-codex",
+	"openai-codex/gpt-5.2-codex",
+	"openai-codex/gpt-5.1-codex"
+];
+const XHIGH_MODEL_SET = new Set(XHIGH_MODEL_REFS.map((entry) => entry.toLowerCase()));
+const XHIGH_MODEL_IDS = new Set(XHIGH_MODEL_REFS.map((entry) => entry.split("/")[1]?.toLowerCase()).filter((entry) => Boolean(entry)));
+function normalizeThinkLevel(raw) {
+	if (!raw) return;
+	const key = raw.trim().toLowerCase();
+	const collapsed = key.replace(/[\s_-]+/g, "");
+	if (collapsed === "xhigh" || collapsed === "extrahigh") return "xhigh";
+	if (["off"].includes(key)) return "off";
+	if ([
+		"on",
+		"enable",
+		"enabled"
+	].includes(key)) return "low";
+	if (["min", "minimal"].includes(key)) return "minimal";
+	if ([
+		"low",
+		"thinkhard",
+		"think-hard",
+		"think_hard"
+	].includes(key)) return "low";
+	if ([
+		"mid",
+		"med",
+		"medium",
+		"thinkharder",
+		"think-harder",
+		"harder"
+	].includes(key)) return "medium";
+	if ([
+		"high",
+		"ultra",
+		"ultrathink",
+		"think-hard",
+		"thinkhardest",
+		"highest",
+		"max"
+	].includes(key)) return "high";
+	if (["think"].includes(key)) return "minimal";
+}
+function supportsXHighThinking(provider, model) {
+	const modelKey = model?.trim().toLowerCase();
+	if (!modelKey) return false;
+	const providerKey = provider?.trim().toLowerCase();
+	if (providerKey) return XHIGH_MODEL_SET.has(`${providerKey}/${modelKey}`);
+	return XHIGH_MODEL_IDS.has(modelKey);
+}
+function listThinkingLevels(provider, model) {
+	const levels = [
+		"off",
+		"minimal",
+		"low",
+		"medium",
+		"high"
+	];
+	if (supportsXHighThinking(provider, model)) levels.push("xhigh");
+	return levels;
+}
+function listThinkingLevelLabels(provider, model) {
+	if (isBinaryThinkingProvider(provider)) return ["off", "on"];
+	return listThinkingLevels(provider, model);
+}
+function formatThinkingLevels(provider, model, separator = ", ") {
+	return listThinkingLevelLabels(provider, model).join(separator);
+}
+function formatXHighModelHint() {
+	const refs = [...XHIGH_MODEL_REFS];
+	if (refs.length === 0) return "unknown model";
+	if (refs.length === 1) return refs[0];
+	if (refs.length === 2) return `${refs[0]} or ${refs[1]}`;
+	return `${refs.slice(0, -1).join(", ")} or ${refs[refs.length - 1]}`;
+}
+function normalizeVerboseLevel(raw) {
+	if (!raw) return;
+	const key = raw.toLowerCase();
+	if ([
+		"off",
+		"false",
+		"no",
+		"0"
+	].includes(key)) return "off";
+	if ([
+		"full",
+		"all",
+		"everything"
+	].includes(key)) return "full";
+	if ([
+		"on",
+		"minimal",
+		"true",
+		"yes",
+		"1"
+	].includes(key)) return "on";
+}
+function normalizeUsageDisplay(raw) {
+	if (!raw) return;
+	const key = raw.toLowerCase();
+	if ([
+		"off",
+		"false",
+		"no",
+		"0",
+		"disable",
+		"disabled"
+	].includes(key)) return "off";
+	if ([
+		"on",
+		"true",
+		"yes",
+		"1",
+		"enable",
+		"enabled"
+	].includes(key)) return "tokens";
+	if ([
+		"tokens",
+		"token",
+		"tok",
+		"minimal",
+		"min"
+	].includes(key)) return "tokens";
+	if (["full", "session"].includes(key)) return "full";
+}
+function resolveResponseUsageMode(raw) {
+	return normalizeUsageDisplay(raw) ?? "off";
+}
+function normalizeElevatedLevel(raw) {
+	if (!raw) return;
+	const key = raw.toLowerCase();
+	if ([
+		"off",
+		"false",
+		"no",
+		"0"
+	].includes(key)) return "off";
+	if ([
+		"full",
+		"auto",
+		"auto-approve",
+		"autoapprove"
+	].includes(key)) return "full";
+	if ([
+		"ask",
+		"prompt",
+		"approval",
+		"approve"
+	].includes(key)) return "ask";
+	if ([
+		"on",
+		"true",
+		"yes",
+		"1"
+	].includes(key)) return "on";
+}
+function normalizeReasoningLevel(raw) {
+	if (!raw) return;
+	const key = raw.toLowerCase();
+	if ([
+		"off",
+		"false",
+		"no",
+		"0",
+		"hide",
+		"hidden",
+		"disable",
+		"disabled"
+	].includes(key)) return "off";
+	if ([
+		"on",
+		"true",
+		"yes",
+		"1",
+		"show",
+		"visible",
+		"enable",
+		"enabled"
+	].includes(key)) return "on";
+	if ([
+		"stream",
+		"streaming",
+		"draft",
+		"live"
+	].includes(key)) return "stream";
+}
+
+//#endregion
+//#region src/agents/pi-embedded-helpers/bootstrap.ts
+function isBase64Signature(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return false;
+	const compact = trimmed.replace(/\s+/g, "");
+	if (!/^[A-Za-z0-9+/=_-]+$/.test(compact)) return false;
+	const isUrl = compact.includes("-") || compact.includes("_");
+	try {
+		const buf = Buffer.from(compact, isUrl ? "base64url" : "base64");
+		if (buf.length === 0) return false;
+		const encoded = buf.toString(isUrl ? "base64url" : "base64");
+		const normalize = (input) => input.replace(/=+$/g, "");
+		return normalize(encoded) === normalize(compact);
+	} catch {
+		return false;
+	}
+}
+/**
+* Strips Claude-style thought_signature fields from content blocks.
+*
+* Gemini expects thought signatures as base64-encoded bytes, but Claude stores message ids
+* like "msg_abc123...". We only strip "msg_*" to preserve any provider-valid signatures.
+*/
+function stripThoughtSignatures(content, options) {
+	if (!Array.isArray(content)) return content;
+	const allowBase64Only = options?.allowBase64Only ?? false;
+	const includeCamelCase = options?.includeCamelCase ?? false;
+	const shouldStripSignature = (value) => {
+		if (!allowBase64Only) return typeof value === "string" && value.startsWith("msg_");
+		return typeof value !== "string" || !isBase64Signature(value);
+	};
+	return content.map((block) => {
+		if (!block || typeof block !== "object") return block;
+		const rec = block;
+		const stripSnake = shouldStripSignature(rec.thought_signature);
+		const stripCamel = includeCamelCase ? shouldStripSignature(rec.thoughtSignature) : false;
+		if (!stripSnake && !stripCamel) return block;
+		const next = { ...rec };
+		if (stripSnake) delete next.thought_signature;
+		if (stripCamel) delete next.thoughtSignature;
+		return next;
+	});
+}
+const DEFAULT_BOOTSTRAP_MAX_CHARS = 2e4;
+const BOOTSTRAP_HEAD_RATIO = .7;
+const BOOTSTRAP_TAIL_RATIO = .2;
+function resolveBootstrapMaxChars(cfg) {
+	const raw = cfg?.agents?.defaults?.bootstrapMaxChars;
+	if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) return Math.floor(raw);
+	return DEFAULT_BOOTSTRAP_MAX_CHARS;
+}
+function trimBootstrapContent(content, fileName, maxChars) {
+	const trimmed = content.trimEnd();
+	if (trimmed.length <= maxChars) return {
+		content: trimmed,
+		truncated: false,
+		maxChars,
+		originalLength: trimmed.length
+	};
+	const headChars = Math.floor(maxChars * BOOTSTRAP_HEAD_RATIO);
+	const tailChars = Math.floor(maxChars * BOOTSTRAP_TAIL_RATIO);
+	const head = trimmed.slice(0, headChars);
+	const tail = trimmed.slice(-tailChars);
+	return {
+		content: [
+			head,
+			[
+				"",
+				`[...truncated, read ${fileName} for full content...]`,
+				`…(truncated ${fileName}: kept ${headChars}+${tailChars} chars of ${trimmed.length})…`,
+				""
+			].join("\n"),
+			tail
+		].join("\n"),
+		truncated: true,
+		maxChars,
+		originalLength: trimmed.length
+	};
+}
+async function ensureSessionHeader(params) {
+	const file = params.sessionFile;
+	try {
+		await fs.stat(file);
+		return;
+	} catch {}
+	await fs.mkdir(path.dirname(file), { recursive: true });
+	const entry = {
+		type: "session",
+		version: 2,
+		id: params.sessionId,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		cwd: params.cwd
+	};
+	await fs.writeFile(file, `${JSON.stringify(entry)}\n`, "utf-8");
+}
+function buildBootstrapContextFiles(files, opts) {
+	const maxChars = opts?.maxChars ?? DEFAULT_BOOTSTRAP_MAX_CHARS;
+	const result = [];
+	for (const file of files) {
+		if (file.missing) {
+			result.push({
+				path: file.name,
+				content: `[MISSING] Expected at: ${file.path}`
+			});
+			continue;
+		}
+		const trimmed = trimBootstrapContent(file.content ?? "", file.name, maxChars);
+		if (!trimmed.content) continue;
+		if (trimmed.truncated) opts?.warn?.(`workspace bootstrap file ${file.name} is ${trimmed.originalLength} chars (limit ${trimmed.maxChars}); truncating in injected context`);
+		result.push({
+			path: file.name,
+			content: trimmed.content
+		});
+	}
+	return result;
+}
+function sanitizeGoogleTurnOrdering(messages) {
+	const GOOGLE_TURN_ORDER_BOOTSTRAP_TEXT = "(session bootstrap)";
+	const first = messages[0];
+	const role = first?.role;
+	const content = first?.content;
+	if (role === "user" && typeof content === "string" && content.trim() === GOOGLE_TURN_ORDER_BOOTSTRAP_TEXT) return messages;
+	if (role !== "assistant") return messages;
+	return [{
+		role: "user",
+		content: GOOGLE_TURN_ORDER_BOOTSTRAP_TEXT,
+		timestamp: Date.now()
+	}, ...messages];
+}
+
+//#endregion
+//#region src/agents/pi-embedded-helpers/errors.ts
+const BILLING_ERROR_USER_MESSAGE = "⚠️ API provider returned a billing error — your API key has run out of credits or has an insufficient balance. Check your provider's billing dashboard and top up or switch to a different API key.";
+function isContextOverflowError(errorMessage) {
+	if (!errorMessage) return false;
+	const lower = errorMessage.toLowerCase();
+	const hasRequestSizeExceeds = lower.includes("request size exceeds");
+	const hasContextWindow = lower.includes("context window") || lower.includes("context length") || lower.includes("maximum context length");
+	return lower.includes("request_too_large") || lower.includes("request exceeds the maximum size") || lower.includes("context length exceeded") || lower.includes("maximum context length") || lower.includes("prompt is too long") || lower.includes("exceeds model context window") || hasRequestSizeExceeds && hasContextWindow || lower.includes("context overflow") || lower.includes("413") && lower.includes("too large");
+}
+const CONTEXT_WINDOW_TOO_SMALL_RE = /context window.*(too small|minimum is)/i;
+const CONTEXT_OVERFLOW_HINT_RE = /context.*overflow|context window.*(too (?:large|long)|exceed|over|limit|max(?:imum)?|requested|sent|tokens)|(?:prompt|request|input).*(too (?:large|long)|exceed|over|limit|max(?:imum)?)/i;
+function isLikelyContextOverflowError(errorMessage) {
+	if (!errorMessage) return false;
+	if (CONTEXT_WINDOW_TOO_SMALL_RE.test(errorMessage)) return false;
+	if (isContextOverflowError(errorMessage)) return true;
+	return CONTEXT_OVERFLOW_HINT_RE.test(errorMessage);
+}
+function isCompactionFailureError(errorMessage) {
+	if (!errorMessage) return false;
+	if (!isContextOverflowError(errorMessage)) return false;
+	const lower = errorMessage.toLowerCase();
+	return lower.includes("summarization failed") || lower.includes("auto-compaction") || lower.includes("compaction failed") || lower.includes("compaction");
+}
+const ERROR_PAYLOAD_PREFIX_RE = /^(?:error|api\s*error|apierror|openai\s*error|anthropic\s*error|gateway\s*error)[:\s-]+/i;
+const FINAL_TAG_RE = /<\s*\/?\s*final\s*>/gi;
+const ERROR_PREFIX_RE = /^(?:error|api\s*error|openai\s*error|anthropic\s*error|gateway\s*error|request failed|failed|exception)[:\s-]+/i;
+const HTTP_STATUS_PREFIX_RE = /^(?:http\s*)?(\d{3})\s+(.+)$/i;
+const HTTP_ERROR_HINTS = [
+	"error",
+	"bad request",
+	"not found",
+	"unauthorized",
+	"forbidden",
+	"internal server",
+	"service unavailable",
+	"gateway",
+	"rate limit",
+	"overloaded",
+	"timeout",
+	"timed out",
+	"invalid",
+	"too many requests",
+	"permission"
+];
+function stripFinalTagsFromText(text) {
+	if (!text) return text;
+	return text.replace(FINAL_TAG_RE, "");
+}
+function collapseConsecutiveDuplicateBlocks(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return text;
+	const blocks = trimmed.split(/\n{2,}/);
+	if (blocks.length < 2) return text;
+	const normalizeBlock = (value) => value.trim().replace(/\s+/g, " ");
+	const result = [];
+	let lastNormalized = null;
+	for (const block of blocks) {
+		const normalized = normalizeBlock(block);
+		if (lastNormalized && normalized === lastNormalized) continue;
+		result.push(block.trim());
+		lastNormalized = normalized;
+	}
+	if (result.length === blocks.length) return text;
+	return result.join("\n\n");
+}
+function isLikelyHttpErrorText(raw) {
+	const match = raw.match(HTTP_STATUS_PREFIX_RE);
+	if (!match) return false;
+	const code = Number(match[1]);
+	if (!Number.isFinite(code) || code < 400) return false;
+	const message = match[2].toLowerCase();
+	return HTTP_ERROR_HINTS.some((hint) => message.includes(hint));
+}
+function isErrorPayloadObject(payload) {
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+	const record = payload;
+	if (record.type === "error") return true;
+	if (typeof record.request_id === "string" || typeof record.requestId === "string") return true;
+	if ("error" in record) {
+		const err = record.error;
+		if (err && typeof err === "object" && !Array.isArray(err)) {
+			const errRecord = err;
+			if (typeof errRecord.message === "string" || typeof errRecord.type === "string" || typeof errRecord.code === "string") return true;
+		}
+	}
+	return false;
+}
+function parseApiErrorPayload(raw) {
+	if (!raw) return null;
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	const candidates = [trimmed];
+	if (ERROR_PAYLOAD_PREFIX_RE.test(trimmed)) candidates.push(trimmed.replace(ERROR_PAYLOAD_PREFIX_RE, "").trim());
+	for (const candidate of candidates) {
+		if (!candidate.startsWith("{") || !candidate.endsWith("}")) continue;
+		try {
+			const parsed = JSON.parse(candidate);
+			if (isErrorPayloadObject(parsed)) return parsed;
+		} catch {}
+	}
+	return null;
+}
+function stableStringify(value) {
+	if (!value || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+	const record = value;
+	return `{${Object.keys(record).toSorted().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function getApiErrorPayloadFingerprint(raw) {
+	if (!raw) return null;
+	const payload = parseApiErrorPayload(raw);
+	if (!payload) return null;
+	return stableStringify(payload);
+}
+function isRawApiErrorPayload(raw) {
+	return getApiErrorPayloadFingerprint(raw) !== null;
+}
+function parseApiErrorInfo(raw) {
+	if (!raw) return null;
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	let httpCode;
+	let candidate = trimmed;
+	const httpPrefixMatch = candidate.match(/^(\d{3})\s+(.+)$/s);
+	if (httpPrefixMatch) {
+		httpCode = httpPrefixMatch[1];
+		candidate = httpPrefixMatch[2].trim();
+	}
+	const payload = parseApiErrorPayload(candidate);
+	if (!payload) return null;
+	const requestId = typeof payload.request_id === "string" ? payload.request_id : typeof payload.requestId === "string" ? payload.requestId : void 0;
+	const topType = typeof payload.type === "string" ? payload.type : void 0;
+	const topMessage = typeof payload.message === "string" ? payload.message : void 0;
+	let errType;
+	let errMessage;
+	if (payload.error && typeof payload.error === "object" && !Array.isArray(payload.error)) {
+		const err = payload.error;
+		if (typeof err.type === "string") errType = err.type;
+		if (typeof err.code === "string" && !errType) errType = err.code;
+		if (typeof err.message === "string") errMessage = err.message;
+	}
+	return {
+		httpCode,
+		type: errType ?? topType,
+		message: errMessage ?? topMessage,
+		requestId
+	};
+}
+function formatRawAssistantErrorForUi(raw) {
+	const trimmed = (raw ?? "").trim();
+	if (!trimmed) return "LLM request failed with an unknown error.";
+	const httpMatch = trimmed.match(HTTP_STATUS_PREFIX_RE);
+	if (httpMatch) {
+		const rest = httpMatch[2].trim();
+		if (!rest.startsWith("{")) return `HTTP ${httpMatch[1]}: ${rest}`;
+	}
+	const info = parseApiErrorInfo(trimmed);
+	if (info?.message) {
+		const prefix = info.httpCode ? `HTTP ${info.httpCode}` : "LLM error";
+		const type = info.type ? ` ${info.type}` : "";
+		const requestId = info.requestId ? ` (request_id: ${info.requestId})` : "";
+		return `${prefix}${type}: ${info.message}${requestId}`;
+	}
+	return trimmed.length > 600 ? `${trimmed.slice(0, 600)}…` : trimmed;
+}
+function formatAssistantErrorText(msg, opts) {
+	const raw = (msg.errorMessage ?? "").trim();
+	if (msg.stopReason !== "error" && !raw) return;
+	if (!raw) return "LLM request failed with an unknown error.";
+	const unknownTool = raw.match(/unknown tool[:\s]+["']?([a-z0-9_-]+)["']?/i) ?? raw.match(/tool\s+["']?([a-z0-9_-]+)["']?\s+(?:not found|is not available)/i);
+	if (unknownTool?.[1]) {
+		const rewritten = formatSandboxToolPolicyBlockedMessage({
+			cfg: opts?.cfg,
+			sessionKey: opts?.sessionKey,
+			toolName: unknownTool[1]
+		});
+		if (rewritten) return rewritten;
+	}
+	if (isContextOverflowError(raw)) return "Context overflow: prompt too large for the model. Try again with less input or a larger-context model.";
+	if (/incorrect role information|roles must alternate|400.*role|"message".*role.*information/i.test(raw)) return "Message ordering conflict - please try again. If this persists, use /new to start a fresh session.";
+	if (isMissingToolCallInputError(raw)) return "Session history looks corrupted (tool call input missing). Use /new to start a fresh session. If this keeps happening, reset the session or delete the corrupted session transcript.";
+	const invalidRequest = raw.match(/"type":"invalid_request_error".*?"message":"([^"]+)"/);
+	if (invalidRequest?.[1]) return `LLM request rejected: ${invalidRequest[1]}`;
+	if (isOverloadedErrorMessage(raw)) return "The AI service is temporarily overloaded. Please try again in a moment.";
+	if (isBillingErrorMessage(raw)) return BILLING_ERROR_USER_MESSAGE;
+	if (isLikelyHttpErrorText(raw) || isRawApiErrorPayload(raw)) return formatRawAssistantErrorForUi(raw);
+	if (raw.length > 600) console.warn("[formatAssistantErrorText] Long error truncated:", raw.slice(0, 200));
+	return raw.length > 600 ? `${raw.slice(0, 600)}…` : raw;
+}
+function sanitizeUserFacingText(text) {
+	if (!text) return text;
+	const stripped = stripFinalTagsFromText(text);
+	const trimmed = stripped.trim();
+	if (!trimmed) return stripped;
+	if (/incorrect role information|roles must alternate/i.test(trimmed)) return "Message ordering conflict - please try again. If this persists, use /new to start a fresh session.";
+	if (isContextOverflowError(trimmed)) return "Context overflow: prompt too large for the model. Try again with less input or a larger-context model.";
+	if (isBillingErrorMessage(trimmed)) return BILLING_ERROR_USER_MESSAGE;
+	if (isRawApiErrorPayload(trimmed) || isLikelyHttpErrorText(trimmed)) return formatRawAssistantErrorForUi(trimmed);
+	if (ERROR_PREFIX_RE.test(trimmed)) {
+		if (isOverloadedErrorMessage(trimmed) || isRateLimitErrorMessage(trimmed)) return "The AI service is temporarily overloaded. Please try again in a moment.";
+		if (isTimeoutErrorMessage(trimmed)) return "LLM request timed out.";
+		return formatRawAssistantErrorForUi(trimmed);
+	}
+	return collapseConsecutiveDuplicateBlocks(stripped);
+}
+function isRateLimitAssistantError(msg) {
+	if (!msg || msg.stopReason !== "error") return false;
+	return isRateLimitErrorMessage(msg.errorMessage ?? "");
+}
+const ERROR_PATTERNS = {
+	rateLimit: [
+		/rate[_ ]limit|too many requests|429/,
+		"exceeded your current quota",
+		"resource has been exhausted",
+		"quota exceeded",
+		"resource_exhausted",
+		"usage limit"
+	],
+	overloaded: [/overloaded_error|"type"\s*:\s*"overloaded_error"/i, "overloaded"],
+	timeout: [
+		"timeout",
+		"timed out",
+		"deadline exceeded",
+		"context deadline exceeded"
+	],
+	billing: [
+		/\b402\b/,
+		"payment required",
+		"insufficient credits",
+		"credit balance",
+		"plans & billing"
+	],
+	auth: [
+		/invalid[_ ]?api[_ ]?key/,
+		"incorrect api key",
+		"invalid token",
+		"authentication",
+		"re-authenticate",
+		"oauth token refresh failed",
+		"unauthorized",
+		"forbidden",
+		"access denied",
+		"expired",
+		"token has expired",
+		/\b401\b/,
+		/\b403\b/,
+		"no credentials found",
+		"no api key found"
+	],
+	format: [
+		"string should match pattern",
+		"tool_use.id",
+		"tool_use_id",
+		"messages.1.content.1.tool_use.id",
+		"invalid request format"
+	]
+};
+const TOOL_CALL_INPUT_MISSING_RE = /tool_(?:use|call)\.(?:input|arguments).*?(?:field required|required)/i;
+const TOOL_CALL_INPUT_PATH_RE = /messages\.\d+\.content\.\d+\.tool_(?:use|call)\.(?:input|arguments)/i;
+const IMAGE_DIMENSION_ERROR_RE = /image dimensions exceed max allowed size for many-image requests:\s*(\d+)\s*pixels/i;
+const IMAGE_DIMENSION_PATH_RE = /messages\.(\d+)\.content\.(\d+)\.image/i;
+const IMAGE_SIZE_ERROR_RE = /image exceeds\s*(\d+(?:\.\d+)?)\s*mb/i;
+function matchesErrorPatterns(raw, patterns) {
+	if (!raw) return false;
+	const value = raw.toLowerCase();
+	return patterns.some((pattern) => pattern instanceof RegExp ? pattern.test(value) : value.includes(pattern));
+}
+function isRateLimitErrorMessage(raw) {
+	return matchesErrorPatterns(raw, ERROR_PATTERNS.rateLimit);
+}
+function isTimeoutErrorMessage(raw) {
+	return matchesErrorPatterns(raw, ERROR_PATTERNS.timeout);
+}
+function isBillingErrorMessage(raw) {
+	const value = raw.toLowerCase();
+	if (!value) return false;
+	if (matchesErrorPatterns(value, ERROR_PATTERNS.billing)) return true;
+	return value.includes("billing") && (value.includes("upgrade") || value.includes("credits") || value.includes("payment") || value.includes("plan"));
+}
+function isMissingToolCallInputError(raw) {
+	if (!raw) return false;
+	return TOOL_CALL_INPUT_MISSING_RE.test(raw) || TOOL_CALL_INPUT_PATH_RE.test(raw);
+}
+function isBillingAssistantError(msg) {
+	if (!msg || msg.stopReason !== "error") return false;
+	return isBillingErrorMessage(msg.errorMessage ?? "");
+}
+function isAuthErrorMessage(raw) {
+	return matchesErrorPatterns(raw, ERROR_PATTERNS.auth);
+}
+function isOverloadedErrorMessage(raw) {
+	return matchesErrorPatterns(raw, ERROR_PATTERNS.overloaded);
+}
+function parseImageDimensionError(raw) {
+	if (!raw) return null;
+	if (!raw.toLowerCase().includes("image dimensions exceed max allowed size")) return null;
+	const limitMatch = raw.match(IMAGE_DIMENSION_ERROR_RE);
+	const pathMatch = raw.match(IMAGE_DIMENSION_PATH_RE);
+	return {
+		maxDimensionPx: limitMatch?.[1] ? Number.parseInt(limitMatch[1], 10) : void 0,
+		messageIndex: pathMatch?.[1] ? Number.parseInt(pathMatch[1], 10) : void 0,
+		contentIndex: pathMatch?.[2] ? Number.parseInt(pathMatch[2], 10) : void 0,
+		raw
+	};
+}
+function isImageDimensionErrorMessage(raw) {
+	return Boolean(parseImageDimensionError(raw));
+}
+function parseImageSizeError(raw) {
+	if (!raw) return null;
+	const lower = raw.toLowerCase();
+	if (!lower.includes("image exceeds") || !lower.includes("mb")) return null;
+	const match = raw.match(IMAGE_SIZE_ERROR_RE);
+	return {
+		maxMb: match?.[1] ? Number.parseFloat(match[1]) : void 0,
+		raw
+	};
+}
+function isImageSizeError(errorMessage) {
+	if (!errorMessage) return false;
+	return Boolean(parseImageSizeError(errorMessage));
+}
+function isCloudCodeAssistFormatError(raw) {
+	return !isImageDimensionErrorMessage(raw) && matchesErrorPatterns(raw, ERROR_PATTERNS.format);
+}
+function isAuthAssistantError(msg) {
+	if (!msg || msg.stopReason !== "error") return false;
+	return isAuthErrorMessage(msg.errorMessage ?? "");
+}
+function classifyFailoverReason(raw) {
+	if (isImageDimensionErrorMessage(raw)) return null;
+	if (isImageSizeError(raw)) return null;
+	if (isRateLimitErrorMessage(raw)) return "rate_limit";
+	if (isOverloadedErrorMessage(raw)) return "rate_limit";
+	if (isCloudCodeAssistFormatError(raw)) return "format";
+	if (isBillingErrorMessage(raw)) return "billing";
+	if (isTimeoutErrorMessage(raw)) return "timeout";
+	if (isAuthErrorMessage(raw)) return "auth";
+	return null;
+}
+function isFailoverErrorMessage(raw) {
+	return classifyFailoverReason(raw) !== null;
+}
+function isFailoverAssistantError(msg) {
+	if (!msg || msg.stopReason !== "error") return false;
+	return isFailoverErrorMessage(msg.errorMessage ?? "");
+}
+
+//#endregion
+//#region src/agents/pi-embedded-helpers/google.ts
+function isGoogleModelApi(api) {
+	return api === "google-gemini-cli" || api === "google-generative-ai" || api === "google-antigravity";
+}
+function isAntigravityClaude(params) {
+	const provider = params.provider?.toLowerCase();
+	const api = params.api?.toLowerCase();
+	if (provider !== "google-antigravity" && api !== "google-antigravity") return false;
+	return params.modelId?.toLowerCase().includes("claude") ?? false;
+}
+
+//#endregion
+//#region src/agents/pi-embedded-helpers/openai.ts
+function parseOpenAIReasoningSignature(value) {
+	if (!value) return null;
+	let candidate = null;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+		try {
+			candidate = JSON.parse(trimmed);
+		} catch {
+			return null;
+		}
+	} else if (typeof value === "object") candidate = value;
+	if (!candidate) return null;
+	const id = typeof candidate.id === "string" ? candidate.id : "";
+	const type = typeof candidate.type === "string" ? candidate.type : "";
+	if (!id.startsWith("rs_")) return null;
+	if (type === "reasoning" || type.startsWith("reasoning.")) return {
+		id,
+		type
+	};
+	return null;
+}
+function hasFollowingNonThinkingBlock(content, index) {
+	for (let i = index + 1; i < content.length; i++) {
+		const block = content[i];
+		if (!block || typeof block !== "object") return true;
+		if (block.type !== "thinking") return true;
+	}
+	return false;
+}
+/**
+* OpenAI Responses API can reject transcripts that contain a standalone `reasoning` item id
+* without the required following item.
+*
+* OpenClaw persists provider-specific reasoning metadata in `thinkingSignature`; if that metadata
+* is incomplete, drop the block to keep history usable.
+*/
+function downgradeOpenAIReasoningBlocks(messages) {
+	const out = [];
+	for (const msg of messages) {
+		if (!msg || typeof msg !== "object") {
+			out.push(msg);
+			continue;
+		}
+		if (msg.role !== "assistant") {
+			out.push(msg);
+			continue;
+		}
+		const assistantMsg = msg;
+		if (!Array.isArray(assistantMsg.content)) {
+			out.push(msg);
+			continue;
+		}
+		let changed = false;
+		const nextContent = [];
+		for (let i = 0; i < assistantMsg.content.length; i++) {
+			const block = assistantMsg.content[i];
+			if (!block || typeof block !== "object") {
+				nextContent.push(block);
+				continue;
+			}
+			const record = block;
+			if (record.type !== "thinking") {
+				nextContent.push(block);
+				continue;
+			}
+			if (!parseOpenAIReasoningSignature(record.thinkingSignature)) {
+				nextContent.push(block);
+				continue;
+			}
+			if (hasFollowingNonThinkingBlock(assistantMsg.content, i)) {
+				nextContent.push(block);
+				continue;
+			}
+			changed = true;
+		}
+		if (!changed) {
+			out.push(msg);
+			continue;
+		}
+		if (nextContent.length === 0) continue;
+		out.push({
+			...assistantMsg,
+			content: nextContent
+		});
+	}
+	return out;
+}
+
+//#endregion
+//#region src/agents/tool-call-id.ts
+const STRICT9_LEN = 9;
+/**
+* Sanitize a tool call ID to be compatible with various providers.
+*
+* - "strict" mode: only [a-zA-Z0-9]
+* - "strict9" mode: only [a-zA-Z0-9], length 9 (Mistral tool call requirement)
+*/
+function sanitizeToolCallId(id, mode = "strict") {
+	if (!id || typeof id !== "string") {
+		if (mode === "strict9") return "defaultid";
+		return "defaulttoolid";
+	}
+	if (mode === "strict9") {
+		const alphanumericOnly = id.replace(/[^a-zA-Z0-9]/g, "");
+		if (alphanumericOnly.length >= STRICT9_LEN) return alphanumericOnly.slice(0, STRICT9_LEN);
+		if (alphanumericOnly.length > 0) return shortHash(alphanumericOnly, STRICT9_LEN);
+		return shortHash("sanitized", STRICT9_LEN);
+	}
+	const alphanumericOnly = id.replace(/[^a-zA-Z0-9]/g, "");
+	return alphanumericOnly.length > 0 ? alphanumericOnly : "sanitizedtoolid";
+}
+function shortHash(text, length = 8) {
+	return createHash("sha1").update(text).digest("hex").slice(0, length);
+}
+function makeUniqueToolId(params) {
+	if (params.mode === "strict9") {
+		const base = sanitizeToolCallId(params.id, params.mode);
+		const candidate = base.length >= STRICT9_LEN ? base.slice(0, STRICT9_LEN) : "";
+		if (candidate && !params.used.has(candidate)) return candidate;
+		for (let i = 0; i < 1e3; i += 1) {
+			const hashed = shortHash(`${params.id}:${i}`, STRICT9_LEN);
+			if (!params.used.has(hashed)) return hashed;
+		}
+		return shortHash(`${params.id}:${Date.now()}`, STRICT9_LEN);
+	}
+	const MAX_LEN = 40;
+	const base = sanitizeToolCallId(params.id, params.mode).slice(0, MAX_LEN);
+	if (!params.used.has(base)) return base;
+	const hash = shortHash(params.id);
+	const separator = params.mode === "strict" ? "" : "_";
+	const maxBaseLen = MAX_LEN - separator.length - hash.length;
+	const candidate = `${base.length > maxBaseLen ? base.slice(0, maxBaseLen) : base}${separator}${hash}`;
+	if (!params.used.has(candidate)) return candidate;
+	for (let i = 2; i < 1e3; i += 1) {
+		const suffix = params.mode === "strict" ? `x${i}` : `_${i}`;
+		const next = `${candidate.slice(0, MAX_LEN - suffix.length)}${suffix}`;
+		if (!params.used.has(next)) return next;
+	}
+	const ts = params.mode === "strict" ? `t${Date.now()}` : `_${Date.now()}`;
+	return `${candidate.slice(0, MAX_LEN - ts.length)}${ts}`;
+}
+function rewriteAssistantToolCallIds(params) {
+	const content = params.message.content;
+	if (!Array.isArray(content)) return params.message;
+	let changed = false;
+	const next = content.map((block) => {
+		if (!block || typeof block !== "object") return block;
+		const rec = block;
+		const type = rec.type;
+		const id = rec.id;
+		if (type !== "functionCall" && type !== "toolUse" && type !== "toolCall" || typeof id !== "string" || !id) return block;
+		const nextId = params.resolve(id);
+		if (nextId === id) return block;
+		changed = true;
+		return {
+			...block,
+			id: nextId
+		};
+	});
+	if (!changed) return params.message;
+	return {
+		...params.message,
+		content: next
+	};
+}
+function rewriteToolResultIds(params) {
+	const toolCallId = typeof params.message.toolCallId === "string" && params.message.toolCallId ? params.message.toolCallId : void 0;
+	const toolUseId = params.message.toolUseId;
+	const toolUseIdStr = typeof toolUseId === "string" && toolUseId ? toolUseId : void 0;
+	const nextToolCallId = toolCallId ? params.resolve(toolCallId) : void 0;
+	const nextToolUseId = toolUseIdStr ? params.resolve(toolUseIdStr) : void 0;
+	if (nextToolCallId === toolCallId && nextToolUseId === toolUseIdStr) return params.message;
+	return {
+		...params.message,
+		...nextToolCallId && { toolCallId: nextToolCallId },
+		...nextToolUseId && { toolUseId: nextToolUseId }
+	};
+}
+/**
+* Sanitize tool call IDs for provider compatibility.
+*
+* @param messages - The messages to sanitize
+* @param mode - "strict" (alphanumeric only) or "strict9" (alphanumeric length 9)
+*/
+function sanitizeToolCallIdsForCloudCodeAssist(messages, mode = "strict") {
+	const map = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	const resolve = (id) => {
+		const existing = map.get(id);
+		if (existing) return existing;
+		const next = makeUniqueToolId({
+			id,
+			used,
+			mode
+		});
+		map.set(id, next);
+		used.add(next);
+		return next;
+	};
+	let changed = false;
+	const out = messages.map((msg) => {
+		if (!msg || typeof msg !== "object") return msg;
+		const role = msg.role;
+		if (role === "assistant") {
+			const next = rewriteAssistantToolCallIds({
+				message: msg,
+				resolve
+			});
+			if (next !== msg) changed = true;
+			return next;
+		}
+		if (role === "toolResult") {
+			const next = rewriteToolResultIds({
+				message: msg,
+				resolve
+			});
+			if (next !== msg) changed = true;
+			return next;
+		}
+		return msg;
+	});
+	return changed ? out : messages;
+}
+
+//#endregion
+//#region src/agents/tool-images.ts
+const MAX_IMAGE_DIMENSION_PX = 2e3;
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+const log = createSubsystemLogger("agents/tool-images");
+function isImageBlock(block) {
+	if (!block || typeof block !== "object") return false;
+	const rec = block;
+	return rec.type === "image" && typeof rec.data === "string" && typeof rec.mimeType === "string";
+}
+function isTextBlock(block) {
+	if (!block || typeof block !== "object") return false;
+	const rec = block;
+	return rec.type === "text" && typeof rec.text === "string";
+}
+function inferMimeTypeFromBase64(base64) {
+	const trimmed = base64.trim();
+	if (!trimmed) return;
+	if (trimmed.startsWith("/9j/")) return "image/jpeg";
+	if (trimmed.startsWith("iVBOR")) return "image/png";
+	if (trimmed.startsWith("R0lGOD")) return "image/gif";
+}
+async function resizeImageBase64IfNeeded(params) {
+	const buf = Buffer.from(params.base64, "base64");
+	const meta = await getImageMetadata(buf);
+	const width = meta?.width;
+	const height = meta?.height;
+	const overBytes = buf.byteLength > params.maxBytes;
+	const hasDimensions = typeof width === "number" && typeof height === "number";
+	if (hasDimensions && !overBytes && width <= params.maxDimensionPx && height <= params.maxDimensionPx) return {
+		base64: params.base64,
+		mimeType: params.mimeType,
+		resized: false,
+		width,
+		height
+	};
+	if (hasDimensions && (width > params.maxDimensionPx || height > params.maxDimensionPx || overBytes)) log.warn("Image exceeds limits; resizing", {
+		label: params.label,
+		width,
+		height,
+		maxDimensionPx: params.maxDimensionPx,
+		maxBytes: params.maxBytes
+	});
+	const qualities = [
+		85,
+		75,
+		65,
+		55,
+		45,
+		35
+	];
+	const maxDim = hasDimensions ? Math.max(width ?? 0, height ?? 0) : params.maxDimensionPx;
+	const sideGrid = [
+		maxDim > 0 ? Math.min(params.maxDimensionPx, maxDim) : params.maxDimensionPx,
+		1800,
+		1600,
+		1400,
+		1200,
+		1e3,
+		800
+	].map((v) => Math.min(params.maxDimensionPx, v)).filter((v, i, arr) => v > 0 && arr.indexOf(v) === i).toSorted((a, b) => b - a);
+	let smallest = null;
+	for (const side of sideGrid) for (const quality of qualities) {
+		const out = await resizeToJpeg({
+			buffer: buf,
+			maxSide: side,
+			quality,
+			withoutEnlargement: true
+		});
+		if (!smallest || out.byteLength < smallest.size) smallest = {
+			buffer: out,
+			size: out.byteLength
+		};
+		if (out.byteLength <= params.maxBytes) {
+			log.info("Image resized", {
+				label: params.label,
+				width,
+				height,
+				maxDimensionPx: params.maxDimensionPx,
+				maxBytes: params.maxBytes,
+				originalBytes: buf.byteLength,
+				resizedBytes: out.byteLength,
+				quality,
+				side
+			});
+			return {
+				base64: out.toString("base64"),
+				mimeType: "image/jpeg",
+				resized: true,
+				width,
+				height
+			};
+		}
+	}
+	const best = smallest?.buffer ?? buf;
+	const maxMb = (params.maxBytes / (1024 * 1024)).toFixed(0);
+	const gotMb = (best.byteLength / (1024 * 1024)).toFixed(2);
+	throw new Error(`Image could not be reduced below ${maxMb}MB (got ${gotMb}MB)`);
+}
+async function sanitizeContentBlocksImages(blocks, label, opts = {}) {
+	const maxDimensionPx = Math.max(opts.maxDimensionPx ?? MAX_IMAGE_DIMENSION_PX, 1);
+	const maxBytes = Math.max(opts.maxBytes ?? MAX_IMAGE_BYTES, 1);
+	const out = [];
+	for (const block of blocks) {
+		if (!isImageBlock(block)) {
+			out.push(block);
+			continue;
+		}
+		const data = block.data.trim();
+		if (!data) {
+			out.push({
+				type: "text",
+				text: `[${label}] omitted empty image payload`
+			});
+			continue;
+		}
+		try {
+			const mimeType = inferMimeTypeFromBase64(data) ?? block.mimeType;
+			const resized = await resizeImageBase64IfNeeded({
+				base64: data,
+				mimeType,
+				maxDimensionPx,
+				maxBytes,
+				label
+			});
+			out.push({
+				...block,
+				data: resized.base64,
+				mimeType: resized.resized ? resized.mimeType : mimeType
+			});
+		} catch (err) {
+			out.push({
+				type: "text",
+				text: `[${label}] omitted image payload: ${String(err)}`
+			});
+		}
+	}
+	return out;
+}
+async function sanitizeImageBlocks(images, label, opts = {}) {
+	if (images.length === 0) return {
+		images,
+		dropped: 0
+	};
+	const next = (await sanitizeContentBlocksImages(images, label, opts)).filter(isImageBlock);
+	return {
+		images: next,
+		dropped: Math.max(0, images.length - next.length)
+	};
+}
+async function sanitizeToolResultImages(result, label, opts = {}) {
+	const content = Array.isArray(result.content) ? result.content : [];
+	if (!content.some((b) => isImageBlock(b) || isTextBlock(b))) return result;
+	const next = await sanitizeContentBlocksImages(content, label, opts);
+	return {
+		...result,
+		content: next
+	};
+}
+
+//#endregion
+//#region src/agents/pi-embedded-helpers/images.ts
+async function sanitizeSessionMessagesImages(messages, label, options) {
+	const allowNonImageSanitization = (options?.sanitizeMode ?? "full") === "full";
+	const sanitizedIds = allowNonImageSanitization && options?.sanitizeToolCallIds ? sanitizeToolCallIdsForCloudCodeAssist(messages, options.toolCallIdMode) : messages;
+	const out = [];
+	for (const msg of sanitizedIds) {
+		if (!msg || typeof msg !== "object") {
+			out.push(msg);
+			continue;
+		}
+		const role = msg.role;
+		if (role === "toolResult") {
+			const toolMsg = msg;
+			const nextContent = await sanitizeContentBlocksImages(Array.isArray(toolMsg.content) ? toolMsg.content : [], label);
+			out.push({
+				...toolMsg,
+				content: nextContent
+			});
+			continue;
+		}
+		if (role === "user") {
+			const userMsg = msg;
+			const content = userMsg.content;
+			if (Array.isArray(content)) {
+				const nextContent = await sanitizeContentBlocksImages(content, label);
+				out.push({
+					...userMsg,
+					content: nextContent
+				});
+				continue;
+			}
+		}
+		if (role === "assistant") {
+			const assistantMsg = msg;
+			if (assistantMsg.stopReason === "error") {
+				const content = assistantMsg.content;
+				if (Array.isArray(content)) {
+					const nextContent = await sanitizeContentBlocksImages(content, label);
+					out.push({
+						...assistantMsg,
+						content: nextContent
+					});
+				} else out.push(assistantMsg);
+				continue;
+			}
+			const content = assistantMsg.content;
+			if (Array.isArray(content)) {
+				if (!allowNonImageSanitization) {
+					const nextContent = await sanitizeContentBlocksImages(content, label);
+					out.push({
+						...assistantMsg,
+						content: nextContent
+					});
+					continue;
+				}
+				const finalContent = await sanitizeContentBlocksImages((options?.preserveSignatures ? content : stripThoughtSignatures(content, options?.sanitizeThoughtSignatures)).filter((block) => {
+					if (!block || typeof block !== "object") return true;
+					const rec = block;
+					if (rec.type !== "text" || typeof rec.text !== "string") return true;
+					return rec.text.trim().length > 0;
+				}), label);
+				if (finalContent.length === 0) continue;
+				out.push({
+					...assistantMsg,
+					content: finalContent
+				});
+				continue;
+			}
+		}
+		out.push(msg);
+	}
+	return out;
+}
+
+//#endregion
+//#region src/agents/pi-embedded-helpers/messaging-dedupe.ts
+const MIN_DUPLICATE_TEXT_LENGTH = 10;
+/**
+* Normalize text for duplicate comparison.
+* - Trims whitespace
+* - Lowercases
+* - Strips emoji (Emoji_Presentation and Extended_Pictographic)
+* - Collapses multiple spaces to single space
+*/
+function normalizeTextForComparison(text) {
+	return text.trim().toLowerCase().replace(/\p{Emoji_Presentation}|\p{Extended_Pictographic}/gu, "").replace(/\s+/g, " ").trim();
+}
+function isMessagingToolDuplicateNormalized(normalized, normalizedSentTexts) {
+	if (normalizedSentTexts.length === 0) return false;
+	if (!normalized || normalized.length < MIN_DUPLICATE_TEXT_LENGTH) return false;
+	return normalizedSentTexts.some((normalizedSent) => {
+		if (!normalizedSent || normalizedSent.length < MIN_DUPLICATE_TEXT_LENGTH) return false;
+		return normalized.includes(normalizedSent) || normalizedSent.includes(normalized);
+	});
+}
+function isMessagingToolDuplicate(text, sentTexts) {
+	if (sentTexts.length === 0) return false;
+	const normalized = normalizeTextForComparison(text);
+	if (!normalized || normalized.length < MIN_DUPLICATE_TEXT_LENGTH) return false;
+	return isMessagingToolDuplicateNormalized(normalized, sentTexts.map(normalizeTextForComparison));
+}
+
+//#endregion
+//#region src/agents/pi-embedded-helpers/thinking.ts
+function extractSupportedValues(raw) {
+	const match = raw.match(/supported values are:\s*([^\n.]+)/i) ?? raw.match(/supported values:\s*([^\n.]+)/i);
+	if (!match?.[1]) return [];
+	const fragment = match[1];
+	const quoted = Array.from(fragment.matchAll(/['"]([^'"]+)['"]/g)).map((entry) => entry[1]?.trim());
+	if (quoted.length > 0) return quoted.filter((entry) => Boolean(entry));
+	return fragment.split(/,|\band\b/gi).map((entry) => entry.replace(/^[^a-zA-Z]+|[^a-zA-Z]+$/g, "").trim()).filter(Boolean);
+}
+function pickFallbackThinkingLevel(params) {
+	const raw = params.message?.trim();
+	if (!raw) return;
+	const supported = extractSupportedValues(raw);
+	if (supported.length === 0) return;
+	for (const entry of supported) {
+		const normalized = normalizeThinkLevel(entry);
+		if (!normalized) continue;
+		if (params.attempted.has(normalized)) continue;
+		return normalized;
+	}
+}
+
+//#endregion
+//#region src/agents/pi-embedded-helpers/turns.ts
+/**
+* Validates and fixes conversation turn sequences for Gemini API.
+* Gemini requires strict alternating user→assistant→tool→user pattern.
+* Merges consecutive assistant messages together.
+*/
+function validateGeminiTurns(messages) {
+	if (!Array.isArray(messages) || messages.length === 0) return messages;
+	const result = [];
+	let lastRole;
+	for (const msg of messages) {
+		if (!msg || typeof msg !== "object") {
+			result.push(msg);
+			continue;
+		}
+		const msgRole = msg.role;
+		if (!msgRole) {
+			result.push(msg);
+			continue;
+		}
+		if (msgRole === lastRole && lastRole === "assistant") {
+			const lastMsg = result[result.length - 1];
+			const currentMsg = msg;
+			if (lastMsg && typeof lastMsg === "object") {
+				const lastAsst = lastMsg;
+				const mergedContent = [...Array.isArray(lastAsst.content) ? lastAsst.content : [], ...Array.isArray(currentMsg.content) ? currentMsg.content : []];
+				const merged = {
+					...lastAsst,
+					content: mergedContent,
+					...currentMsg.usage && { usage: currentMsg.usage },
+					...currentMsg.stopReason && { stopReason: currentMsg.stopReason },
+					...currentMsg.errorMessage && { errorMessage: currentMsg.errorMessage }
+				};
+				result[result.length - 1] = merged;
+				continue;
+			}
+		}
+		result.push(msg);
+		lastRole = msgRole;
+	}
+	return result;
+}
+function mergeConsecutiveUserTurns(previous, current) {
+	const mergedContent = [...Array.isArray(previous.content) ? previous.content : [], ...Array.isArray(current.content) ? current.content : []];
+	return {
+		...current,
+		content: mergedContent,
+		timestamp: current.timestamp ?? previous.timestamp
+	};
+}
+/**
+* Validates and fixes conversation turn sequences for Anthropic API.
+* Anthropic requires strict alternating user→assistant pattern.
+* Merges consecutive user messages together.
+*/
+function validateAnthropicTurns(messages) {
+	if (!Array.isArray(messages) || messages.length === 0) return messages;
+	const result = [];
+	let lastRole;
+	for (const msg of messages) {
+		if (!msg || typeof msg !== "object") {
+			result.push(msg);
+			continue;
+		}
+		const msgRole = msg.role;
+		if (!msgRole) {
+			result.push(msg);
+			continue;
+		}
+		if (msgRole === lastRole && lastRole === "user") {
+			const lastMsg = result[result.length - 1];
+			const currentMsg = msg;
+			if (lastMsg && typeof lastMsg === "object") {
+				const merged = mergeConsecutiveUserTurns(lastMsg, currentMsg);
+				result[result.length - 1] = merged;
+				continue;
+			}
+		}
+		result.push(msg);
+		lastRole = msgRole;
+	}
+	return result;
+}
+
+//#endregion
+export { parseImageSizeError as A, normalizeElevatedLevel as B, isFailoverAssistantError as C, isRawApiErrorPayload as D, isRateLimitAssistantError as E, sanitizeGoogleTurnOrdering as F, resolveResponseUsageMode as G, normalizeThinkLevel as H, formatThinkingLevels as I, supportsXHighThinking as K, formatXHighModelHint as L, buildBootstrapContextFiles as M, ensureSessionHeader as N, isTimeoutErrorMessage as O, resolveBootstrapMaxChars as P, listThinkingLevelLabels as R, isContextOverflowError as S, isLikelyContextOverflowError as T, normalizeUsageDisplay as U, normalizeReasoningLevel as V, normalizeVerboseLevel as W, getApiErrorPayloadFingerprint as _, isMessagingToolDuplicateNormalized as a, isCloudCodeAssistFormatError as b, sanitizeImageBlocks as c, isAntigravityClaude as d, isGoogleModelApi as f, formatRawAssistantErrorForUi as g, formatAssistantErrorText as h, isMessagingToolDuplicate as i, sanitizeUserFacingText as j, parseImageDimensionError as k, sanitizeToolResultImages as l, classifyFailoverReason as m, validateGeminiTurns as n, normalizeTextForComparison as o, BILLING_ERROR_USER_MESSAGE as p, pickFallbackThinkingLevel as r, sanitizeSessionMessagesImages as s, validateAnthropicTurns as t, downgradeOpenAIReasoningBlocks as u, isAuthAssistantError as v, isFailoverErrorMessage as w, isCompactionFailureError as x, isBillingAssistantError as y, listThinkingLevels as z };