@bike4mind/cli 0.20.1 → 0.20.2

package/dist/{AgentHistoryStore-BQiATPsQ.mjs → AgentHistoryStore-T7Oh84Yn.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as WORK_ITEM_STATUSES, A as HttpStatus, At as usdToCredits, B as REASONING_EFFORT_INCOMPATIBLE_WITH_TOOLS_MODELS, Ct as mapMimeTypeToArtifactType, D as FORMAT_PROMPT_TEMPLATE, Dt as settingsMap, E as FIXED_TEMPERATURE_MODELS, Et as secureParameters, F as NO_TEMPERATURE_MODELS, Ft as isNearLimit, G as SupportedFabFileMimeTypes, H as REFUSAL_FALLBACK_MODELS, I as NotFoundError, It as parseRateLimitHeaders, J as UnauthorizedError, K as TTS_MAX_INPUT_CHARS, L as OllamaEmbeddingModel, M as InternalServerError, Mt as withRetry, N as MODEL_INFO_FIELD_GROUP_OF, Nt as buildRateLimitLogEntry, O as ForbiddenError, Ot as toModelInfo, P as ModelBackend, Pt as extractSnippetMeta, Q as VoyageAIEmbeddingModel, R as OpenAIEmbeddingModel, S as CorruptedFileError, St as isZodError, T as FIELD_GROUP_OF, Tt as resolveHistoryFetchLimit, U as RESPONSES_API_TOOL_MODELS, V as REASONING_SUPPORTED_MODELS, W as SpeechToTextModels, X as VIDEO_SIZE_CONSTRAINTS, Y as UnprocessableEntityError, Z as VideoModels, _ as BadRequestError, _t as isRenderableModelType, at as getQuestErrorCode, bt as isUnlimitedHistory, ct as isFieldGroup, dt as isImageAttachment, et as applyModelPriceCatalog, ft as isImageServeable, g as BFL_SAFETY_TOLERANCE, gt as isPlaceholderApiKey, h as BEDROCK_NO_PROMPT_CACHING_MODELS, ht as isModelDeprecated, it as getMcpProviderMetadata, j as ImageModels, jt as usdToCreditsStochastic, k as HTTPError, kt as toModelRecord, lt as isGPTImage2Model, m as ApiKeyType, mt as isModelAccessible, n as logger, nt as dayjsConfig_default, ot as getRetryAfterMs, p as ARTIFACT_ATTRS_PATTERN, pt as isMediaModelType, q as TooManyRequestsError, rt as defaultEmbeddingModelForEnv, st as isAudioMimeType, tt as calculateRetryDelay, ut as isGPTImageModel, v as BedrockEmbeddingModel, vt as isRetryableError, w as DEFAULT_UNKNOWN_CONTEXT_WINDOW, wt as obfuscateApiKey, x as ChatModels, xt as isUserInitiatedAbort, y as CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS, yt as isSupportedFabFileMimeType, z as PermissionDeniedError } from "./ConfigStore-CNfbeaJf.mjs";
+import { $ as VoyageAIEmbeddingModel, A as HTTPError, At as resolveHistoryFetchLimit, B as PermissionDeniedError, Bt as isNearLimit, Ct as isRetryableError, D as FIXED_TEMPERATURE_MODELS, Dt as isZodError, E as FIELD_GROUP_OF, Et as isUserInitiatedAbort, F as ModelBackend, Ft as usdToCredits, G as SpeechToTextModels, H as REASONING_SUPPORTED_MODELS, I as NO_TEMPERATURE_MODELS, It as usdToCreditsStochastic, J as TooManyRequestsError, K as SupportedFabFileMimeTypes, L as NotFoundError, Lt as withRetry, M as ImageModels, Mt as settingsMap, N as InternalServerError, Nt as toModelInfo, O as FORMAT_PROMPT_TEMPLATE, Ot as mapMimeTypeToArtifactType, P as MODEL_INFO_FIELD_GROUP_OF, Pt as toModelRecord, Q as VideoModels, R as OllamaEmbeddingModel, Rt as buildRateLimitLogEntry, S as CorruptedFileError, St as isRenderableModelType, Tt as isUnlimitedHistory, U as REFUSAL_FALLBACK_MODELS, V as REASONING_EFFORT_INCOMPATIBLE_WITH_TOOLS_MODELS, Vt as parseRateLimitHeaders, W as RESPONSES_API_TOOL_MODELS, X as UnprocessableEntityError, Y as UnauthorizedError, Z as VIDEO_SIZE_CONSTRAINTS, _ as BadRequestError, _t as isImageServeable, at as getMcpProviderMetadata, bt as isModelDeprecated, ct as isAudioMimeType, et as WORK_ITEM_STATUSES, ft as isFieldGroup, g as BFL_SAFETY_TOLERANCE, gt as isImageAttachment, h as BEDROCK_NO_PROMPT_CACHING_MODELS, ht as isGeminiModelId, it as defaultEmbeddingModelForEnv, j as HttpStatus, jt as secureParameters, k as ForbiddenError, kt as obfuscateApiKey, lt as isChunkRebuildPending, m as ApiKeyType, mt as isGPTImageModel, n as logger, nt as calculateRetryDelay, ot as getQuestErrorCode, p as ARTIFACT_ATTRS_PATTERN, pt as isGPTImage2Model, q as TTS_MAX_INPUT_CHARS, rt as dayjsConfig_default, st as getRetryAfterMs, tt as applyModelPriceCatalog, ut as isConvergencePausedNote, v as BedrockEmbeddingModel, vt as isMediaModelType, w as DEFAULT_UNKNOWN_CONTEXT_WINDOW, wt as isSupportedFabFileMimeType, x as ChatModels, xt as isPlaceholderApiKey, y as CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS, yt as isModelAccessible, z as OpenAIEmbeddingModel, zt as extractSnippetMeta } from "./ConfigStore-cIyF7hDg.mjs";
 import { n as isPathAllowed, t as assertPathAllowed } from "./pathValidation-D8tjkQXE-1HwvsuYT.mjs";
 import { n as isTerminalShellStatus, t as getShellSessionManager } from "./ShellSessionManager-6o8KZzl1-vrbPAUTq.mjs";
 import { execFile, execFileSync, spawn } from "child_process";
@@ -37,13 +37,14 @@ import OpenAI from "openai";
 import { VoyageAIClient } from "voyageai";
 import mime from "mime-types";
 import dns from "dns";
+import http from "http";
+import https, { Agent } from "https";
 import { promisify } from "util";
 import { DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 import { Readable } from "stream";
 import { fileTypeFromBuffer } from "file-type";
 import { NodeHttpHandler } from "@smithy/node-http-handler";
-import { Agent } from "https";
 import "@opensearch-project/opensearch";
 import "@aws-sdk/credential-provider-node";
 import "@opensearch-project/opensearch/aws-v3";
@@ -110,6 +111,18 @@ const COMPACTION_SUMMARY_MARKER = "[Previous conversation summary]";
 //#endregion
 //#region src/utils/fileSearch.ts
 /**
+* stat() that yields null instead of throwing. Following a symlink is best-effort here:
+* a dangling link, or one pointing somewhere unreadable, must not take down a whole
+* directory listing.
+*/
+function statOrNull(targetPath) {
+	try {
+		return fs$2.statSync(targetPath);
+	} catch {
+		return null;
+	}
+}
+/**
 * Load gitignore rules from project root
 */
 function loadIgnoreRules(projectRoot) {
@@ -200,13 +213,17 @@ function listAbsoluteDirectory(absolutePath, filterQuery) {
 		}
 		return filteredEntries.slice(0, 15).map((entry) => {
 			const fullPath = path$1.join(normalizedPath, entry.name);
+			const target = entry.isSymbolicLink() ? statOrNull(fullPath) : null;
+			const isDirectory = target ? target.isDirectory() : entry.isDirectory();
+			const isFile = target ? target.isFile() : entry.isFile();
 			const result = {
 				path: fullPath,
-				isDirectory: entry.isDirectory()
+				isDirectory
 			};
-			if (entry.isFile()) try {
-				result.size = fs$2.statSync(fullPath).size;
-			} catch {}
+			if (isFile) {
+				const fileStats = target ?? statOrNull(fullPath);
+				if (fileStats) result.size = fileStats.size;
+			}
 			return result;
 		});
 	} catch {
@@ -1555,7 +1572,7 @@ function webFetchBody(result) {
 	if (result.extractedChars === 0 && result.offset > 0) return `[web_fetch: offset ${result.offset} is at or beyond the end of the content (~${result.originalChars} chars); nothing further to read.]`;
 	return result.truncated ? result.markdown + truncationMarker(result) : result.markdown;
 }
-function isPdfUrl(url) {
+function isPdfUrl$2(url) {
 	try {
 		const { pathname } = new URL(url);
 		return pathname.toLowerCase().endsWith(".pdf");
@@ -1615,7 +1632,7 @@ async function probeLlmsTxt(pageUrl) {
 */
 async function firecrawlFetch(adapters, url, options) {
 	if (!/^https?:\/\/.+/i.test(url)) throw new Error(`Invalid URL format: ${url}. URL must start with http:// or https://`);
-	const isPdf = isPdfUrl(url);
+	const isPdf = isPdfUrl$2(url);
 	const desiredTimeout = isPdf ? PDF_TIMEOUT_MS : DEFAULT_TIMEOUT_MS;
 	const timeoutMs = options?.maxTimeoutMs ? Math.min(desiredTimeout, options.maxTimeoutMs) : desiredTimeout;
 	const app = createFirecrawlApp(await (0, apiKeyService_exports.getFirecrawlConfig)(adapters));
@@ -2044,7 +2061,7 @@ const webSearchTool = {
 	})
 };
 //#endregion
-//#region ../../b4m-core/services/dist/toolGenerators-BVUZiwqE.mjs
+//#region ../../b4m-core/services/dist/toolGenerators-D3QFkvc-.mjs
 const diceRoll = async (parameters) => {
 	if (!parameters?.sides || !parameters?.times) throw new Error("Tool dice roll: Missing required parameters");
 	return sum(times(parameters.times, () => random(1, parameters.sides))).toString();
@@ -2731,11 +2748,12 @@ const askUserQuestionTool = {
 * re-export them without pulling the full tool graph. `index.ts` re-exports them
 * so the server barrel's public API is unchanged.
 */
-const generateTools = (userId, user, logger, { db, retrievalFilter, kbScope, inlinedAttachmentIds, fullyInlinedAttachmentIds }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model, imageProcessorLambdaName, tools, allowedDirectories, entitlementKeys = [], sessionId, codeMinifier, availableModels, onToolLlmUsage) => {
+const generateTools = (userId, user, logger, { db, retrievalFilter, kbScope, inlinedAttachmentIds, fullyInlinedAttachmentIds, suppressLakeArms, sessionRetrievalTags, questId, getAbortSignal }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model, imageProcessorLambdaName, tools, allowedDirectories, entitlementKeys = [], sessionId, codeMinifier, availableModels, onToolLlmUsage) => {
 	const context = {
 		userId,
 		user,
 		sessionId,
+		questId,
 		logger,
 		db,
 		storage,
@@ -2752,9 +2770,12 @@ const generateTools = (userId, user, logger, { db, retrievalFilter, kbScope, inl
 		kbScope,
 		inlinedAttachmentIds,
 		fullyInlinedAttachmentIds,
+		suppressLakeArms,
+		sessionRetrievalTags,
 		codeMinifier,
 		availableModels,
-		onToolLlmUsage
+		onToolLlmUsage,
+		getAbortSignal
 	};
 	return Object.entries(tools).reduce((acc, [key, tool]) => ({
 		...acc,
@@ -5438,6 +5459,61 @@ function extractCommandName(filename) {
 	return name;
 }
 //#endregion
+//#region src/utils/findMarkdownFiles.ts
+/**
+* Classify a directory entry, resolving symlinks by their target.
+*
+* `fs.readdir(withFileTypes)` builds each Dirent from the entry itself, never
+* the link target, so a symlink reports `isFile() === false` AND
+* `isDirectory() === false`. A walk keyed off those two predicates alone skips
+* every symlinked entry.
+*/
+async function classifyEntry(fullPath, entry) {
+	if (!entry.isSymbolicLink()) {
+		if (entry.isDirectory()) return "directory";
+		return entry.isFile() ? "file" : "other";
+	}
+	try {
+		const stats = await fs$1.stat(fullPath);
+		if (stats.isDirectory()) return "directory";
+		return stats.isFile() ? "file" : "other";
+	} catch {
+		return "other";
+	}
+}
+/**
+* Recursively collect every `.md` file under `directory`, following symlinks.
+*
+* Symlink support is load-bearing, not a nicety: dotfile managers (nix
+* home-manager, chezmoi, a plain dotfiles repo) materialize
+* `~/.claude/skills/<name>/SKILL.md` as a symlink into an immutable store, so a
+* walk that only accepts real files finds zero global skills on those machines.
+*
+* Directories are deduped by realpath so a cyclic link cannot spin forever.
+*/
+async function findMarkdownFiles(directory, visitedRealPaths = /* @__PURE__ */ new Set()) {
+	const files = [];
+	try {
+		const realDirectory = await fs$1.realpath(directory);
+		if (visitedRealPaths.has(realDirectory)) return files;
+		visitedRealPaths.add(realDirectory);
+	} catch {}
+	let entries;
+	try {
+		entries = await fs$1.readdir(directory, { withFileTypes: true });
+	} catch (error) {
+		console.warn(`Error reading directory ${directory}:`, error instanceof Error ? error.message : String(error));
+		return files;
+	}
+	for (const entry of entries) {
+		const fullPath = path.join(directory, entry.name);
+		const kind = await classifyEntry(fullPath, entry);
+		if (kind === "directory") files.push(...await findMarkdownFiles(fullPath, visitedRealPaths));
+		else if (kind === "file" && entry.name.endsWith(".md")) files.push(fullPath);
+	}
+	return files;
+}
+//#endregion
 //#region src/storage/CustomCommandStore.ts
 var CustomCommandStore = class {
 	constructor(projectRoot, options = {}) {
@@ -5515,7 +5591,7 @@ var CustomCommandStore = class {
 	async loadCommandsFromDirectory(directory, source) {
 		try {
 			if (!(await fs$1.stat(directory)).isDirectory()) return;
-			const commandFiles = await this.findCommandFiles(directory);
+			const commandFiles = await findMarkdownFiles(directory);
 			for (const filePath of commandFiles) try {
 				await this.loadCommandFile(filePath, source);
 			} catch (error) {
@@ -5526,28 +5602,6 @@ var CustomCommandStore = class {
 		}
 	}
 	/**
-	* Recursively finds all .md files in a directory
-	*
-	* @param directory - Directory to search
-	* @returns Array of full file paths to .md files
-	*/
-	async findCommandFiles(directory) {
-		const files = [];
-		try {
-			const entries = await fs$1.readdir(directory, { withFileTypes: true });
-			for (const entry of entries) {
-				const fullPath = path.join(directory, entry.name);
-				if (entry.isDirectory()) {
-					const subFiles = await this.findCommandFiles(fullPath);
-					files.push(...subFiles);
-				} else if (entry.isFile() && entry.name.endsWith(".md")) files.push(fullPath);
-			}
-		} catch (error) {
-			console.warn(`Error reading directory ${directory}:`, error instanceof Error ? error.message : String(error));
-		}
-		return files;
-	}
-	/**
 	* Loads a single command file
 	*
 	* @param filePath - Full path to the command file
@@ -7045,6 +7099,7 @@ var SmartChunker = class {
 	encoder;
 	storage;
 	bufferPercentOrValue;
+	lastExtractedText;
 	/**
 	* @param model - The embedding model name
 	* @param storage - Storage instance for file content
@@ -7098,6 +7153,13 @@ var SmartChunker = class {
 			this.encoder = void 0;
 		}
 	}
+	/**
+	* The canonical extracted text from the most recent chunkFile() call - policy-independent, unlike
+	* the returned chunks. Undefined when the file yielded no extractable text. See lastExtractedText.
+	*/
+	getExtractedText() {
+		return this.lastExtractedText;
+	}
 	async chunkFile(fileOrContent, mimeType) {
 		let content;
 		if (Buffer.isBuffer(fileOrContent)) content = fileOrContent;
@@ -7107,6 +7169,7 @@ var SmartChunker = class {
 		}
 		this.logger.updateMetadata({ mimeType });
 		this.logger.log(`Chunking file with type: ${mimeType}`);
+		this.lastExtractedText = void 0;
 		if (isAudioMimeType(mimeType)) {
 			this.logger.log(`Skipping chunking for audio file type: ${mimeType}`);
 			return [];
@@ -7144,12 +7207,17 @@ var SmartChunker = class {
 			case SupportedFabFileMimeTypes.PHP:
 			case SupportedFabFileMimeTypes.RUBY:
 			case SupportedFabFileMimeTypes.SH:
-			case SupportedFabFileMimeTypes.BASH:
-				chunks = await this.chunkText(content.toString());
+			case SupportedFabFileMimeTypes.BASH: {
+				const textContent = content.toString();
+				this.lastExtractedText = textContent;
+				chunks = await this.chunkText(textContent);
 				break;
+			}
 			default:
 				if (mimeType && mimeType.startsWith("text/")) {
-					chunks = await this.chunkText(content.toString());
+					const textContent = content.toString();
+					this.lastExtractedText = textContent;
+					chunks = await this.chunkText(textContent);
 					break;
 				}
 				this.logger.error(`Unsupported file type: ${mimeType}`);
@@ -7161,7 +7229,9 @@ var SmartChunker = class {
 		return await this.storage.getContentAsBuffer(file.filePath);
 	}
 	async chunkCSV(content) {
-		const rows = content.toString("utf8").split(/\r?\n/).filter((row) => row.trim().length > 0);
+		const csvString = content.toString("utf8");
+		this.lastExtractedText = csvString;
+		const rows = csvString.split(/\r?\n/).filter((row) => row.trim().length > 0);
 		const chunks = [];
 		let currentChunk = [];
 		let currentTokens = 0;
@@ -7214,6 +7284,7 @@ var SmartChunker = class {
 	async chunkPDF(content) {
 		const pdf = await getDocumentProxy(new Uint8Array(content));
 		const { text } = await extractText(pdf);
+		this.lastExtractedText = Array.isArray(text) ? text.join("\n") : text;
 		if (typeof text === "string") return this.chunkText(text);
 		const chunks = [];
 		let currentChunk = "";
@@ -7245,7 +7316,9 @@ var SmartChunker = class {
 		return chunks;
 	}
 	async chunkJSON(content) {
-		const json = JSON.parse(content.toString());
+		const jsonString = content.toString();
+		this.lastExtractedText = jsonString;
+		const json = JSON.parse(jsonString);
 		return this.chunkObject(json);
 	}
 	async chunkObject(obj) {
@@ -7312,6 +7385,7 @@ var SmartChunker = class {
 	}
 	async chunkDOCX(content) {
 		const result = await mammoth.extractRawText({ buffer: content });
+		this.lastExtractedText = result.value;
 		return this.chunkText(result.value);
 	}
 	async chunkPPTX(content) {
@@ -7330,6 +7404,7 @@ var SmartChunker = class {
 			this.logger.warn("PPTX contained no extractable slide text");
 			return [];
 		}
+		this.lastExtractedText = fullText;
 		return this.chunkText(fullText);
 	}
 	async chunkText(content) {
@@ -7404,6 +7479,9 @@ var SmartChunker = class {
 	async chunkExcel(content) {
 		const { read, utils } = await import("xlsx");
 		const workbook = read(content, { type: "buffer" });
+		this.lastExtractedText = workbook.SheetNames.map((sheetName) => {
+			return `--- Sheet: ${sheetName} ---\n${utils.sheet_to_json(workbook.Sheets[sheetName], { header: 1 }).filter(Array.isArray).map((row) => JSON.stringify(row)).join("\n")}\n--- End of Sheet: ${sheetName} ---`;
+		}).join("\n");
 		const chunks = [];
 		let currentChunk = "";
 		let currentTokens = 0;
@@ -7623,6 +7701,8 @@ const dnsResolve6 = promisify(dns.resolve6);
 * Check if an IPv4 address is in a private/internal range.
 */
 function isPrivateIPv4(ip) {
+	const nonCanonical = ip.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+	if (nonCanonical && nonCanonical.slice(1).some((octet) => octet.length > 1 && octet.startsWith("0"))) return true;
 	const ipv4Match = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
 	if (!ipv4Match) return false;
 	const [, a, b, c] = ipv4Match.map(Number);
@@ -7643,44 +7723,153 @@ function isPrivateIPv4(ip) {
 /**
 * Check if an IPv6 address is in a private/internal range.
 */
+/**
+* Strip the brackets WHATWG URL keeps on an IPv6 hostname: `new URL('http://[::1]/').hostname` is
+* `'[::1]'`, not `'::1'`. Every literal check below compares against unbracketed forms, so without
+* this a bracketed address matched nothing and fell through as safe.
+*
+* Same treatment as the sibling guards in this repo - `ssrfGuard.ts` and `external-image.ts` both
+* strip brackets before their literal checks.
+*/
+function stripIpv6Brackets(hostname) {
+	const h = hostname.toLowerCase();
+	return h.startsWith("[") && h.endsWith("]") ? h.slice(1, -1) : h;
+}
+/**
+* Canonicalize an IPv6 literal to the RFC 5952 form - leading zeros dropped per hextet, longest run of
+* two or more zero hextets compressed to `::`. That is the shape both feeders already hand this module
+* (WHATWG `URL.hostname` at the `validateUrlForFetch` call site, and getaddrinfo answers via
+* `ssrfSafeLookup`), so it is the shape every prefix arm in `isPrivateIPv6` was written against.
+* Canonicalizing once here is what lets those arms cover a family instead of enumerating its legal
+* spellings: `0:0:0:0:0:ffff:127.0.0.1` arrives as `::ffff:127.0.0.1` instead of matching nothing.
+*
+* A dotted IPv4 tail is deliberately kept dotted, unlike WHATWG which hexifies it. The mapped branch
+* below decodes a dotted tail exactly through `isPrivateIPv4` and only blanket-refuses when the tail is
+* hex, so hexifying here would turn `::ffff:8.8.8.8` into an over-block.
+*
+* This cannot over-block: dropping leading zeros only shortens hextets below 0x1000, and every
+* globally routable address is inside 2000::/3 (first hextet 0x2000-0x3fff), which never carries one.
+* Input that does not parse as IPv6 is returned untouched, so it keeps whatever verdict it has today -
+* which is also why the redundant zero-padded arms further down (`2001:0db8:`, `2001:0000:`,
+* `0064:ff9b:`, `0100::`) are left in place rather than deleted.
+*/
+function normalizeIpv6(ip) {
+	const ported = ip.match(/^(\[[^\]]*\]):\d+$/);
+	const bare = stripIpv6Brackets(ported ? ported[1] : ip).replace(/%.*$/, "");
+	const halves = bare.split("::");
+	if (halves.length > 2) return bare;
+	if (halves.length === 2 && halves[0].includes(".")) return bare;
+	const tokens = halves.flatMap((half) => half === "" ? [] : half.split(":"));
+	const dotted = tokens.length > 0 && tokens[tokens.length - 1].includes(".") ? tokens.pop() : void 0;
+	if (!tokens.every((token) => /^[0-9a-f]{1,4}$/.test(token))) return bare;
+	const compressed = halves.length === 2;
+	const width = tokens.length + (dotted ? 2 : 0);
+	if (compressed ? width > 8 : width !== 8) return bare;
+	const hextets = tokens.map((token) => token.replace(/^0+(?=.)/, ""));
+	if (compressed) {
+		const headWidth = halves[0] === "" ? 0 : halves[0].split(":").length;
+		hextets.splice(headWidth, 0, ...new Array(8 - width).fill("0"));
+	}
+	const run = {
+		start: -1,
+		length: 0
+	};
+	for (let i = 0; i < hextets.length; i++) {
+		if (hextets[i] !== "0") continue;
+		let end = i;
+		while (end < hextets.length && hextets[end] === "0") end++;
+		if (end - i > run.length) {
+			run.start = i;
+			run.length = end - i;
+		}
+		i = end;
+	}
+	const body = run.length >= 2 ? `${hextets.slice(0, run.start).join(":")}::${hextets.slice(run.start + run.length).join(":")}` : hextets.join(":");
+	if (dotted === void 0) return body;
+	return body.endsWith(":") ? `${body}${dotted}` : `${body}:${dotted}`;
+}
 function isPrivateIPv6(ip) {
-	const normalized = ip.toLowerCase();
+	const normalized = normalizeIpv6(ip);
+	if (!normalized.includes(":")) return false;
+	if (/[[\]]/.test(normalized)) return true;
+	if (!/^[0-9a-f:.]+$/.test(normalized)) return false;
+	if (normalized.includes(".") && !/^::(ffff:)?\d+\.\d+\.\d+\.\d+$/.test(normalized)) return true;
 	if (normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") return true;
 	if (normalized === "::" || normalized === "0:0:0:0:0:0:0:0") return true;
-	if (normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb")) return true;
+	if (normalized.startsWith("fe")) return true;
 	if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
 	if (normalized.startsWith("ff")) return true;
-	const ipv4MappedMatch = normalized.match(/^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
-	if (ipv4MappedMatch) return isPrivateIPv4(ipv4MappedMatch[1]);
+	if (normalized.startsWith("::ffff:")) {
+		const tail = normalized.slice(7);
+		return /^\d+\.\d+\.\d+\.\d+$/.test(tail) ? isPrivateIPv4(tail) : true;
+	}
+	if (normalized.startsWith("::")) {
+		const tail = normalized.slice(2);
+		return /^\d+\.\d+\.\d+\.\d+$/.test(tail) ? isPrivateIPv4(tail) : true;
+	}
+	if (normalized.startsWith("0:")) return true;
+	if (normalized.startsWith("5f00:")) return true;
+	if (normalized.startsWith("3fff:")) {
+		const rest = normalized.slice(5);
+		if ((rest.startsWith(":") ? 0 : parseInt(rest.split(":")[0], 16)) <= 4095) return true;
+	}
 	if (normalized.startsWith("2001:db8:") || normalized.startsWith("2001:0db8:")) return true;
+	if (normalized.startsWith("2002:")) return true;
+	if (normalized.startsWith("2001:0:") || normalized.startsWith("2001:0000:") || normalized.startsWith("2001::")) return true;
 	if (normalized.startsWith("100::") || normalized.startsWith("0100::")) return true;
 	if (normalized.startsWith("64:ff9b:") || normalized.startsWith("0064:ff9b:")) return true;
 	return false;
 }
 /**
+* Strip what belongs to the interface or the transport rather than to the address: a zone index
+* (`fe80::1%eth0`) and, for an IPv4 literal, a trailing port (`8.8.8.8:443`).
+*
+* MUST be shared by every exported entry point. `isPrivateIP` and `isPrivateOrInternalHostname` each carry
+* their own family gate, and the comment on those gates says why they are kept identical: three gates
+* disagreeing about what counts as IPv4 is how the bracketed-IPv6 hole happened. Stripping in one of them
+* only reproduced exactly that - `8.8.8.8:443` came back public from one export and private from the other,
+* because the second missed its IPv4 branch and was then caught by the misplaced-quad arm.
+*
+* Only a DOTTED port is stripped. An unbracketed `ipv6:port` is genuinely ambiguous - a bare IPv6 address is
+* mostly colons - so it stays refused, and the bracketed spelling is what `normalizeIpv6` handles.
+*/
+function stripZoneAndIpv4Port(host) {
+	const head = host.split("%")[0];
+	const zoneless = head.includes(":") || /^(\d+\.){3}\d+$/.test(head) ? head : host;
+	return zoneless.match(/^((?:\d+\.){3}\d+):\d+$/)?.[1] ?? zoneless;
+}
+/**
 * Check if an IP address (IPv4 or IPv6) is in a private/internal range.
 */
 function isPrivateIP(ip) {
-	if (/^(\d{1,3}\.){3}\d{1,3}$/.test(ip)) return isPrivateIPv4(ip);
-	return isPrivateIPv6(ip);
+	const address = stripZoneAndIpv4Port(ip);
+	if (/^(\d+\.){3}\d+$/.test(address)) return isPrivateIPv4(address);
+	return isPrivateIPv6(address);
 }
 /**
 * Check if a hostname is known to be private/internal.
 * This catches obvious cases before DNS resolution.
 */
 function isPrivateOrInternalHostname(hostname) {
-	const normalized = hostname.toLowerCase();
+	const normalized = stripZoneAndIpv4Port(stripIpv6Brackets(hostname));
 	if (normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1" || normalized === "0.0.0.0" || normalized.endsWith(".localhost") || normalized.endsWith(".local")) return true;
 	if (normalized === "169.254.169.254" || normalized === "instance-data" || normalized === "metadata.google.internal" || normalized === "metadata.internal") return true;
 	if (normalized.endsWith(".cluster.local") || normalized.endsWith(".svc.cluster.local") || normalized.endsWith(".pod.cluster.local")) return true;
-	if (/^(\d{1,3}\.){3}\d{1,3}$/.test(normalized)) return isPrivateIPv4(normalized);
+	if (/^(\d+\.){3}\d+$/.test(normalized)) return isPrivateIPv4(normalized);
 	if (normalized.includes(":")) return isPrivateIPv6(normalized);
 	return false;
 }
 /**
 * Validate a URL before fetching.
 * Blocks internal/private networks to prevent SSRF attacks.
-* Resolves DNS and validates resolved IPs to prevent DNS rebinding attacks.
+*
+* Resolves DNS and rejects the URL if any resolved IP is private. This is a PRE-FLIGHT check, and on
+* its own it does NOT stop DNS rebinding: the address it validates is not the address the eventual
+* socket dials, because the HTTP client resolves the hostname again when it connects. A name that
+* answers with a public IP here and a private one microseconds later passes this check and still
+* reaches the internal destination. `ssrfSafeLookup` below is what closes that window; this function
+* exists to fail fast, to produce a specific user-facing error, and to check the things a connect-time
+* hook cannot see - the scheme, and the literal address the caller actually typed.
 *
 * @param url - The URL to validate
 * @returns Object with valid flag and optional error message
@@ -7692,15 +7881,16 @@ async function validateUrlForFetch(url) {
 			valid: false,
 			error: "URL must use HTTP or HTTPS protocol"
 		};
-		if (isPrivateOrInternalHostname(parsed.hostname)) return {
+		const hostname = stripIpv6Brackets(parsed.hostname);
+		if (isPrivateOrInternalHostname(hostname)) return {
 			valid: false,
 			error: "URL points to a private or internal network"
 		};
-		const isIPv4Address = /^(\d{1,3}\.){3}\d{1,3}$/.test(parsed.hostname);
-		const isIPv6Address = parsed.hostname.includes(":");
+		const isIPv4Address = /^(\d+\.){3}\d+$/.test(hostname);
+		const isIPv6Address = hostname.includes(":");
 		if (!isIPv4Address && !isIPv6Address) try {
-			const ipv4Addresses = await dnsResolve4(parsed.hostname).catch(() => []);
-			const ipv6Addresses = await dnsResolve6(parsed.hostname).catch(() => []);
+			const ipv4Addresses = await dnsResolve4(hostname).catch(() => []);
+			const ipv6Addresses = await dnsResolve6(hostname).catch(() => []);
 			const allAddresses = [...ipv4Addresses, ...ipv6Addresses];
 			if (allAddresses.length === 0) return {
 				valid: false,
@@ -7724,6 +7914,93 @@ async function validateUrlForFetch(url) {
 		};
 	}
 }
+/** Marks a refusal that came from the connect-time hook, so callers can tell it from a DNS failure. */
+const SSRF_BLOCKED_CODE = "ERR_SSRF_BLOCKED_ADDRESS";
+/**
+* DNS lookup that re-validates at CONNECT time. THIS is the check that stops DNS rebinding.
+*
+* The pre-flight in `validateUrlForFetch` resolves the hostname and then hands the NAME to the HTTP
+* client, which resolves it a second time before opening the socket. Those are two different
+* resolutions, so an attacker who controls the authoritative server can answer the first with a
+* public address and the second with `169.254.169.254` - a textbook TOCTOU, and the reason the old
+* "this prevents DNS rebinding attacks" comment on that function was false.
+*
+* Installing this as the agent's `lookup` removes the gap rather than narrowing it: Node passes the
+* address this function returns straight to `net.connect`, so the IP that gets validated is by
+* construction the IP the socket dials. There is no third resolution in between for a rebind to win.
+*
+* Refuses if ANY resolved address is private, matching `validateUrlForFetch` - a dual-stack host must
+* not become reachable just because Node happened to prefer the healthy family this time.
+*
+* The two match in POLICY but deliberately differ in RESOLVER: `validateUrlForFetch` uses
+* `dns.resolve4`/`resolve6` (c-ares, straight to DNS) while this uses `dns.lookup` (getaddrinfo, which
+* also reads `/etc/hosts` and the OS cache). They can therefore legitimately disagree - an
+* `/etc/hosts` entry passes the pre-flight and is refused here. That is fail-closed and the right way
+* round, but it means "the URL validated and then the connection was blocked" is reachable in normal
+* operation and is NOT evidence that the pin is broken.
+*/
+const ssrfSafeLookup = (hostname, options, callback) => {
+	const resolveOptions = {
+		...options,
+		all: true
+	};
+	dns.lookup(hostname, resolveOptions, (err, addresses) => {
+		if (err) {
+			callback(err, "", 0);
+			return;
+		}
+		if (!addresses || addresses.length === 0) {
+			const empty = /* @__PURE__ */ new Error(`No addresses resolved for hostname ${hostname}`);
+			empty.code = "ENOTFOUND";
+			callback(empty, "", 0);
+			return;
+		}
+		const privateHit = addresses.find((entry) => isPrivateIP(entry.address));
+		if (privateHit) {
+			const blocked = /* @__PURE__ */ new Error(`Blocked connection to private IP address (${privateHit.address}) for hostname ${hostname}`);
+			blocked.code = SSRF_BLOCKED_CODE;
+			callback(blocked, "", 0);
+			return;
+		}
+		if (options.all) {
+			callback(null, addresses);
+			return;
+		}
+		callback(null, addresses[0].address, addresses[0].family);
+	});
+};
+/**
+* Agents that pin every connection through `ssrfSafeLookup`.
+*
+* Module-level singletons so sockets and their validation are shared, and deliberately WITHOUT
+* `keepAlive`: a pooled socket outlives the lookup that approved it, and reusing one would skip the
+* connect-time check on every request after the first.
+*
+* Any caller fetching an attacker-influenced URL should pass BOTH - the scheme is not known until
+* after redirects, and an https URL that 302s to http would otherwise slip past a single agent.
+*
+* SCOPE - these protect callers that fetch through Node's http/https stack, which today means
+* `fetchAndParseURL` in `ingest.ts` and nothing else. That does NOT mean other fetchers are unpinned:
+* the webfetch LLM tool (`services/src/llm/tools/implementation/webfetch/plainFetch.ts`) reaches the
+* same guarantee by a different route, and a reader should not go looking for a gap there that is
+* already closed. It vets via `ssrfGuard.ts`, then for http rewrites the URL's hostname to the vetted
+* IP while preserving `Host`, and sets `redirect: 'error'` so a public origin cannot 302-pivot at all.
+* That is connect-by-IP under global `fetch` - so the technique IS available there, and an
+* undici `Agent` with a validating `connect` is not required to pin.
+*
+* The honest residual over there is narrower: https keeps the hostname and leans on TLS validation, so
+* what is left is an SYN-level probe oracle rather than a rebind to a private target. The reason to
+* use the agents here instead is that axios drives a manual redirect chain over an arbitrary number of
+* hops and schemes, where per-request agent selection is the tractable place to enforce this.
+*/
+const ssrfSafeHttpAgent = new http.Agent({
+	lookup: ssrfSafeLookup,
+	keepAlive: false
+});
+const ssrfSafeHttpsAgent = new https.Agent({
+	lookup: ssrfSafeLookup,
+	keepAlive: false
+});
 const URL_REGEX = /https?:\/\/(?:[-\w.])+(?:\:[0-9]+)?(?:\/(?:[\w\/_.])*(?:\?(?:[\w&=%.])*)?(?:\#(?:[\w.])*)?)?/gi;
 function detectURLs(string) {
 	return string.match(URL_REGEX) || [];
@@ -7735,36 +8012,153 @@ function urlExists(stringWithPossibleUrl) {
 	return detectURLs(stringWithPossibleUrl.replace(/\n/g, " ").replace(/,/g, " "));
 }
 const URL_FETCH_TIMEOUT_MS = 1e4;
+/**
+* Redirect hops followed before giving up. Deliberately far below axios's own default of 21: every
+* hop costs a DNS resolution plus a request, and no legitimate document needs more than a couple.
+*/
+const MAX_REDIRECTS = 5;
+/**
+* Hard ceiling on a fetched body. A SAFETY NET against an unbounded response, not a policy limit -
+* `createFabFile` still enforces the `MaxFileSize` admin setting afterwards. Set generously (the
+* same 50MB as the Slack attachment ceiling) so it can never refuse something the app would accept;
+* without it axios defaults to `maxContentLength: -1`, i.e. buffer whatever the server sends, and
+* `@datalake add <link>` takes URLs from anyone who can type in a Slack channel.
+*/
+const URL_MAX_RESPONSE_BYTES = 52428800;
+/**
+* PDF test against the URL's PATH only. The previous form (`url.split('.').pop().startsWith('pdf')`)
+* also matched a query string, so `?doc=report.pdf` on an HTML page was fetched as a PDF.
+*/
+function isPdfUrl(url) {
+	return new URL(url).pathname.toLowerCase().endsWith(".pdf");
+}
+/**
+* True when the body opens with the PDF signature.
+*
+* Closes the door `isPdfUrl` cannot reach: a download endpoint with no `.pdf` in its path, served as
+* `application/octet-stream`, produced neither a Content-Type signal nor an extension signal and was
+* decoded as text - the same `toString('utf8')` corruption the Content-Type fallback exists to
+* prevent, arriving through the one remaining door. `/download?id=123` and `Content-Disposition`
+* attachment links are exactly this shape.
+*
+* Checked at offset 0 only. The PDF spec tolerates leading bytes before the header and readers scan
+* ahead for it, but scanning here would mean sniffing arbitrary attacker-supplied content to
+* RE-CLASSIFY it, and a false positive sends a real text document into the PDF parser. The strict
+* check costs nothing on well-formed files, which is every file this has been observed to affect.
+*
+* Deliberately consulted ONLY on the generic-binary branch, never to override a server that stated a
+* type. A server declaring `text/html` while sending PDF bytes is a different (and unobserved) bug,
+* and overriding an explicit Content-Type is a wider behaviour change than this fix needs.
+*/
+function hasPdfMagicBytes(body) {
+	return body.subarray(0, 5).toString("latin1") === "%PDF-";
+}
+/**
+* Strip embedded credentials before a URL is written to a log.
+*
+* `https://user:pass@host/doc` is a legitimate paste, and this function is reached from the Slack
+* `@datalake add` path and the LLM URL-fetch path - both of which take URLs from whoever can type in
+* a channel or a chat. The FETCH still uses the original URL; only what is recorded is redacted, and a
+* log line outlives the message that produced it.
+*
+* MUST STAY IN SYNC with `sanitizeUrlForRecord` in `apps/client/server/slack/dataLakeLinkIngest.ts`,
+* which does the same job for the PERSISTED provenance record. Deliberately duplicated rather than
+* shared: exporting this would change `fab-pipeline`'s public surface, which its own `index.test.ts`
+* pins as an explicit list of names.
+*/
+function redactUrlCredentials(raw) {
+	try {
+		const parsed = new URL(raw);
+		if (!parsed.username && !parsed.password) return raw;
+		parsed.username = "";
+		parsed.password = "";
+		return parsed.toString();
+	} catch {
+		return "[unparseable url]";
+	}
+}
+/** Last path segment, used only as a display-name fallback when a page has no `<title>`. */
+function lastPathSegment(url) {
+	try {
+		return new URL(url).pathname.split("/").filter(Boolean).pop() ?? url;
+	} catch {
+		return url.split("/")?.pop() ?? url;
+	}
+}
+/**
+* Fetch one URL without following redirects, so the caller can SSRF-validate each hop itself.
+*
+* SECURITY: this is why `maxRedirects: 0` is set rather than left at axios's default. Validating
+* only the URL the user supplied is not enough - axios would follow the redirect chain internally,
+* so any public host could answer `302 Location: http://169.254.169.254/latest/meta-data/` and the
+* guard would never see the address actually fetched.
+*
+* SECURITY: the agents are the OTHER half, and the two guard different attacks. Per-hop
+* `validateUrlForFetch` judges each address the chain names; the agents' `ssrfSafeLookup` judges the
+* IP each socket actually dials. Without the agents a hostname that passes validation and then
+* re-resolves to a private address on connect - DNS rebinding - reaches the internal destination with
+* every URL-level check having passed. Both are needed: the pre-flight sees the scheme and the typed
+* literal, the lookup sees the truth at connect time.
+*
+* `timeoutMs` is the budget REMAINING for the whole operation, not a fresh per-hop allowance - see
+* the deadline in `fetchAndParseURL`.
+*/
+async function fetchWithoutRedirects(url, timeoutMs) {
+	return axios.get(url, {
+		httpAgent: ssrfSafeHttpAgent,
+		httpsAgent: ssrfSafeHttpsAgent,
+		proxy: false,
+		responseType: "arraybuffer",
+		timeout: timeoutMs,
+		maxRedirects: 0,
+		maxContentLength: URL_MAX_RESPONSE_BYTES,
+		maxBodyLength: URL_MAX_RESPONSE_BYTES,
+		validateStatus: (status) => status >= 200 && status < 300 || status >= 300 && status < 400
+	});
+}
 async function fetchAndParseURL(url, { logger }) {
 	logger.updateMetadata({ failedUrl: null });
 	try {
-		const ssrfValidation = await validateUrlForFetch(url);
-		if (!ssrfValidation.valid) throw new Error(`URL blocked for security reasons: ${ssrfValidation.error}`);
-		let urlMimeType = "text/plain";
-		if (url.split(".")?.pop()?.startsWith("pdf")) urlMimeType = "application/pdf";
-		const response = await axios.get(url, {
-			responseType: ["application/pdf"].includes(urlMimeType) ? "arraybuffer" : "text",
-			timeout: URL_FETCH_TIMEOUT_MS
-		});
-		const cheerio = await import("cheerio");
-		const htmlContent = response.data;
-		const $ = cheerio.load(htmlContent);
-		const title = $("title").text() || url.split("/")?.pop();
-		let urlContent = null;
-		switch (urlMimeType) {
-			case "application/pdf":
-				urlContent = Buffer.from(response.data);
-				break;
-			default: {
-				let textContent = "";
-				$("body").find("p").each((index, element) => {
-					textContent += $(element).text() + "\n";
-				});
-				urlContent = textContent || htmlContent;
-				break;
-			}
+		let currentUrl = url;
+		let response = null;
+		const deadline = Date.now() + URL_FETCH_TIMEOUT_MS;
+		for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+			const ssrfValidation = await validateUrlForFetch(currentUrl);
+			if (!ssrfValidation.valid) throw new Error(`URL blocked for security reasons: ${ssrfValidation.error}`);
+			const remainingMs = deadline - Date.now();
+			if (remainingMs <= 0) throw new Error("Timed out while following redirects for URL");
+			response = await fetchWithoutRedirects(currentUrl, remainingMs);
+			if (!(response.status >= 300 && response.status < 400)) break;
+			const location = response.headers?.location;
+			if (typeof location !== "string" || location.length === 0) break;
+			if (hop === MAX_REDIRECTS) throw new Error(`Too many redirects (more than ${MAX_REDIRECTS}) while fetching URL`);
+			currentUrl = new URL(location, currentUrl).toString();
+		}
+		if (!response) throw new Error("URL fetch produced no response");
+		const body = Buffer.isBuffer(response.data) ? response.data : Buffer.from(response.data);
+		const contentType = String(response.headers?.["content-type"] ?? "").toLowerCase();
+		const isGenericBinary = !contentType || contentType.includes("application/octet-stream") || contentType.includes("binary/octet-stream");
+		const urlMimeType = contentType.includes("application/pdf") || isGenericBinary && (isPdfUrl(currentUrl) || hasPdfMagicBytes(body)) ? "application/pdf" : "text/plain";
+		let title;
+		let urlContent;
+		if (urlMimeType === "application/pdf") {
+			urlContent = body;
+			title = lastPathSegment(currentUrl);
+		} else {
+			const cheerio = await import("cheerio");
+			const htmlContent = body.toString("utf8");
+			const $ = cheerio.load(htmlContent);
+			title = $("title").text() || lastPathSegment(currentUrl);
+			let textContent = "";
+			$("body").find("p").each((index, element) => {
+				textContent += $(element).text() + "\n";
+			});
+			urlContent = textContent || htmlContent;
 		}
-		logger.log(`Fetched ${title} with mimetype ${urlMimeType} and parsed ${url}`);
+		const original = redactUrlCredentials(url);
+		const final = redactUrlCredentials(currentUrl);
+		const fetched = original === final ? original : `${original} -> ${final}`;
+		logger.log(`Fetched ${title} with mimetype ${urlMimeType} and parsed ${fetched}`);
 		return {
 			title,
 			textContent: urlContent,
@@ -7772,7 +8166,7 @@ async function fetchAndParseURL(url, { logger }) {
 			ext: mime.extension(urlMimeType) || null
 		};
 	} catch (error) {
-		logger.updateMetadata({ failedUrl: url });
+		logger.updateMetadata({ failedUrl: redactUrlCredentials(url) });
 		logger.debug("Error fetching or parsing URL:", error);
 		throw error;
 	}
@@ -10730,7 +11124,6 @@ var ReActAgent = class extends EventEmitter {
 		this.context = {
 			...context,
 			maxIterations: context.maxIterations ?? 50,
-			maxTokens: context.maxTokens ?? 4096,
 			temperature: context.temperature ?? .7
 		};
 		this.repeatedCallGuard = new RepeatedCallGuard(context.repeatedCallGuard);
@@ -10775,7 +11168,7 @@ var ReActAgent = class extends EventEmitter {
 	*/
 	async completeText(prompt, options = {}) {
 		const model = options.model ?? this.context.model;
-		const maxTokens = options.maxTokens ?? this.context.maxTokens ?? 4096;
+		const maxTokens = options.maxTokens ?? this.context.maxTokens;
 		const temperature = options.temperature ?? this.context.temperature ?? .7;
 		let text = "";
 		await this.context.llm.complete(model, [{
@@ -10816,7 +11209,7 @@ var ReActAgent = class extends EventEmitter {
 		this.isReadOnlyToolFn = options.isReadOnlyTool ?? defaultIsReadOnlyTool;
 		const maxIterations = options.maxIterations ?? this.context.maxIterations ?? 50;
 		const temperature = options.temperature ?? this.context.temperature ?? .7;
-		const maxTokens = options.maxTokens ?? this.context.maxTokens ?? 4096;
+		const maxTokens = options.maxTokens ?? this.context.maxTokens;
 		const maxTotalTokens = options.maxTotalTokens ?? this.context.maxTotalTokens;
 		const maxHistoryIterations = options.maxHistoryIterations ?? 4;
 		let iterations = 0;
@@ -10857,7 +11250,8 @@ var ReActAgent = class extends EventEmitter {
 							totalCacheWriteTokens: this.totalCacheWriteTokens > 0 ? this.totalCacheWriteTokens : void 0,
 							iterations,
 							toolCalls: this.toolCallCount,
-							reachedMaxIterations: false
+							reachedMaxIterations: false,
+							finishReason: this.lastStopReason
 						}
 					};
 					this.emit("complete", result);
@@ -11091,6 +11485,7 @@ var ReActAgent = class extends EventEmitter {
 					toolCalls: this.toolCallCount,
 					reachedMaxIterations,
 					reachedMaxTotalTokens: reachedMaxTotalTokens || void 0,
+					finishReason: this.lastStopReason,
 					averageConfidence: avgConfidence,
 					minConfidence,
 					confidenceLog: this.confidenceLog.length > 0 ? this.confidenceLog : void 0
@@ -11322,7 +11717,7 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
 	async runIteration(query, options = {}) {
 		const maxIterations = options.maxIterations ?? this.context.maxIterations ?? 50;
 		const temperature = options.temperature ?? this.context.temperature ?? .7;
-		const maxTokens = options.maxTokens ?? this.context.maxTokens ?? 4096;
+		const maxTokens = options.maxTokens ?? this.context.maxTokens;
 		const maxTotalTokens = options.maxTotalTokens ?? this.context.maxTotalTokens;
 		if (!this.iterationInitialized) {
 			if (!query) throw new Error("query is required on the first call to runIteration(). Pass the user query, or call fromCheckpoint() first to resume.");
@@ -15107,6 +15502,7 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	buildApiKeyTable: () => buildApiKeyTable,
 	buildSupersededIndex: () => buildSupersededIndex,
 	buildThinkingParams: () => buildThinkingParams,
+	cachedTokensFromUsage: () => cachedTokensFromUsage,
 	catalogLifecycles: () => catalogLifecycles,
 	catalogSuccessors: () => catalogSuccessors,
 	checkStaleModelReferences: () => checkStaleModelReferences,
@@ -15142,6 +15538,7 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	resolveSuccessorChain: () => resolveSuccessorChain,
 	setModelCatalogProvider: () => setModelCatalogProvider,
 	setModelPriceRowsProvider: () => setModelPriceRowsProvider,
+	splitCacheInclusiveInput: () => splitCacheInclusiveInput,
 	stripAllToolBlocks: () => stripAllToolBlocks,
 	stripToolDependentMessages: () => stripToolDependentMessages,
 	toKimiEffort: () => toKimiEffort,
@@ -15227,6 +15624,44 @@ async function runWithConcurrency(tasks, limit) {
 	return results;
 }
 /**
+* Attaches a tool call's outcome onto its `toolsUsed` entry so it survives into
+* `promptMeta.functionCalls.returnValue`/`.success` (see ChatCompletionProcess.ts's mapper
+* and utils.ts's `replayableToolCalls`, which gates a whole replay path on at least one
+* recorded `returnValue`). Every backend pushes a `toolsUsed` entry before executing the
+* tool and only learns the real outcome a few lines later - this is the merge-back.
+*/
+/**
+* Cap applied to a persisted `returnValue` before it reaches Mongo (chars, not bytes). Also the
+* cap on what a later turn replays back to the model for this call (utils.ts's Priority 2
+* reconstruction reads the same persisted, already-truncated value) - this is not a
+* persistence-only limit, it is what a continued conversation sees of an older tool result too.
+*/
+const MAX_RECORDED_TOOL_RESULT_CHARS = 8e3;
+const TOOL_RESULT_TRUNCATION_NOTICE = "\n[tool result truncated]";
+function truncateToolResult(observation) {
+	if (observation.length <= 8e3) return observation;
+	return observation.slice(0, MAX_RECORDED_TOOL_RESULT_CHARS) + TOOL_RESULT_TRUNCATION_NOTICE;
+}
+/**
+* Finds the NOT-YET-STAMPED `toolsUsed` entry for this call (id-first, falling back to the
+* first unstamped entry with the same name when a provider omitted an id) and attaches the
+* truncated result. The "not yet stamped" filter (`success === undefined`) is what keeps this
+* safe across recursive tool-call turns: `toolsUsed` accumulates across rounds, so a later
+* turn's call to the same tool must not overwrite an earlier turn's already-recorded entry.
+* Never throws - a call with no matching entry (e.g. one filtered out before execution) is a
+* silent no-op, matching the tolerance the existing normalize-by-id sites already have.
+*/
+function recordToolResult(toolsUsed, call, observation, success) {
+	const wantId = call.id || void 0;
+	const entry = toolsUsed.find((t) => t.success === void 0 && t.name === call.name && (wantId === void 0 || t.id === wantId));
+	if (!entry) {
+		Logger.globalInstance.debug(`[recordToolResult] no unstamped toolsUsed entry matched name=${call.name} id=${call.id ?? "(none)"} - result not recorded`);
+		return;
+	}
+	entry.returnValue = truncateToolResult(String(observation));
+	entry.success = success;
+}
+/**
 * Helper function to handle tool result streaming for artifact-generating tools
 * This ensures tools like recharts that generate artifacts are streamed immediately
 * rather than waiting for recursive completion calls.
@@ -15742,6 +16177,25 @@ function getCachingAdapter(backend) {
 	return ADAPTERS[backend] || new NoOpCachingAdapter();
 }
 /**
+* Flatten a system message's content to the plain text a provider should receive.
+*
+* System content is usually a string, but the assembly pipeline can hand back an
+* array of content blocks. Both Anthropic-family adapters previously coerced that
+* array with `JSON.stringify` (or bare `String()`), which sent the model literal
+* JSON syntax - escaped quotes and `type`/`text` keys - in place of the prompt.
+*
+* Only `text` blocks are read: Anthropic's `system` accepts text only, so an image
+* or tool block there is already invalid and is dropped rather than serialized into
+* the prompt. Blocks are joined on a newline, matching how separate system messages
+* are joined by the callers.
+*/
+function systemContentToText(content) {
+	if (content === void 0 || content === null) return "";
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((block) => block?.type === "text").map((block) => block.text ?? "").filter((text) => text.trim() !== "").join("\n");
+}
+/**
 * max_tokens floor for adaptive reasoning models (Claude 4.7+/Opus 5). These
 * models self-manage extended thinking *within* max_tokens, which is a ceiling
 * (they stop at end_turn), not a target - so a larger floor costs nothing on
@@ -15805,8 +16259,17 @@ function reasonsWithinOutputBudget(modelInfo) {
 * be consumed entirely by reasoning, leaving an empty visible reply.
 */
 function resolveOutputMaxTokens({ requested, fallback, modelInfo, modelMaxOutputTokens }) {
-	const preferred = requested ?? (reasonsWithinOutputBudget(modelInfo) ? 64e3 : fallback);
-	return Math.min(preferred, modelMaxOutputTokens);
+	const preferred = usableTokenCount(requested) ?? (reasonsWithinOutputBudget(modelInfo) ? 64e3 : fallback);
+	const cap = usableTokenCount(modelMaxOutputTokens);
+	return cap === void 0 ? preferred : Math.min(preferred, cap);
+}
+/**
+* Token counts reaching this module come from catalog rows and external callers, so they are
+* only trustworthy when finite and positive - a zero or negative cap would clamp the budget
+* to an unsendable value just as surely as NaN poisons it.
+*/
+function usableTokenCount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 }
 /**
 * Builds the correct thinking parameters for an Anthropic API call based on
@@ -15995,6 +16458,12 @@ const SLOW_MODEL_REQUEST_TIMEOUT_MS = 12e4;
 */
 const ANTHROPIC_NONSTREAMING_MAX_TOKENS = 21e3;
 /**
+* Output budget used when the caller names none. Only applies to models that do NOT spend
+* reasoning inside the output budget - resolveOutputMaxTokens sizes the rest for the model,
+* so this value stays the historical one and non-reasoning behavior is unchanged.
+*/
+const DEFAULT_ANTHROPIC_MAX_TOKENS = 4096;
+/**
 * Accumulated multi-turn cache token total. Undefined when zero so turns
 * without cache activity keep the pre-cache callback shape.
 */
@@ -16605,7 +17074,8 @@ var AnthropicBackend = class {
 			const systemMessages = messages.filter((m) => m.role === "system");
 			const blocks = [];
 			for (const sm of systemMessages) {
-				const text = typeof sm.content === "string" ? sm.content : JSON.stringify(sm.content);
+				const text = systemContentToText(sm.content);
+				if (text.trim() === "") continue;
 				if (sm.cache === true) blocks.push({
 					type: "text",
 					text,
@@ -16644,7 +17114,11 @@ var AnthropicBackend = class {
 		let { useCount: toolUseCount, resultCount: toolResultCount } = countToolBlocks(filteredMessages);
 		if (toolUseCount > 0 || toolResultCount > 0) {
 			this.logger.debug(`[Pre-API #6181] Sending ${filteredMessages.length} messages with ${toolUseCount} tool_use and ${toolResultCount} tool_result blocks`);
-			if (toolUseCount !== toolResultCount) {
+			if (!options.tools?.length) {
+				this.logger.warn(`[Pre-API #6181] Tool blocks present (tool_use: ${toolUseCount}, tool_result: ${toolResultCount}) but no tools offered this turn. Stripping all tool blocks.`);
+				filteredMessages = stripAllToolBlocks(filteredMessages, this.logger);
+				({useCount: toolUseCount, resultCount: toolResultCount} = countToolBlocks(filteredMessages));
+			} else if (toolUseCount !== toolResultCount) {
 				this.logger.warn(`[Pre-API #6181] Tool block mismatch! tool_use: ${toolUseCount}, tool_result: ${toolResultCount}. Attempting auto-repair...`);
 				filteredMessages = ensureToolPairingIntegrity(filteredMessages, this.logger);
 				({useCount: toolUseCount, resultCount: toolResultCount} = countToolBlocks(filteredMessages));
@@ -16654,9 +17128,15 @@ var AnthropicBackend = class {
 				}
 			}
 		}
+		const currentModelInfo = this.modelRecordFor(model);
 		const apiParams = {
 			model,
-			max_tokens: options.maxTokens ?? 4096,
+			max_tokens: currentModelInfo ? resolveOutputMaxTokens({
+				requested: options.maxTokens,
+				fallback: DEFAULT_ANTHROPIC_MAX_TOKENS,
+				modelInfo: currentModelInfo,
+				modelMaxOutputTokens: currentModelInfo.max_tokens
+			}) : options.maxTokens ?? DEFAULT_ANTHROPIC_MAX_TOKENS,
 			messages: filteredMessages.map((m) => ({
 				role: m.role === "user" ? "user" : "assistant",
 				content: m.content
@@ -16696,7 +17176,6 @@ var AnthropicBackend = class {
 			}
 		}
 		const requestExtraHeaders = anyMessageCacheControlled ? { "anthropic-beta": "prompt-caching-2024-07-31" } : void 0;
-		const currentModelInfo = this.modelRecordFor(model);
 		if (currentModelInfo?.can_think) {
 			const thinkingOptions = options;
 			const isQuestMaster = thinkingOptions.questMaster === true;
@@ -17077,6 +17556,10 @@ var AnthropicBackend = class {
 							if (!parsedParams) {
 								const entry = toolsUsed.find((t) => t.name === name && t.id === id);
 								if (entry) entry.arguments = "{}";
+								recordToolResult(toolsUsed, {
+									id,
+									name
+								}, "Error: Tool parameters were corrupted due to a stream interruption. Please retry.", false);
 								continue;
 							}
 							resolvedTools.push({
@@ -17144,6 +17627,10 @@ var AnthropicBackend = class {
 										toolsUsed
 									});
 								});
+								recordToolResult(toolsUsed, {
+									id: outcome.id,
+									name: outcome.name
+								}, resultStr, true);
 								this.pushToolMessages(messages, {
 									id: toolId,
 									name: outcome.name,
@@ -17151,16 +17638,22 @@ var AnthropicBackend = class {
 								}, resultStr);
 							} else {
 								if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
+								const errorMessage = outcome.error instanceof Error ? outcome.error.message : "Unknown error";
 								this.logger.error("[Tool Execution] Tool failed", {
 									model,
 									toolName: outcome.name,
-									error: outcome.error instanceof Error ? outcome.error.message : "Unknown error"
+									error: errorMessage
 								});
+								const observation = `Error processing ${outcome.name} tool: ${errorMessage}`;
+								recordToolResult(toolsUsed, {
+									id: outcome.id,
+									name: outcome.name
+								}, observation, false);
 								this.pushToolMessages(messages, {
 									id: toolId,
 									name: outcome.name,
 									parameters: outcome.parameters
-								}, `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`);
+								}, observation);
 							}
 						}
 						await cb(["\n\n"], { toolsUsed });
@@ -17297,7 +17790,13 @@ var AnthropicBackend = class {
 								isMcpTool,
 								streaming: false
 							}, messages);
-							if (!parsedParams) continue;
+							if (!parsedParams) {
+								recordToolResult(toolsUsed, {
+									id,
+									name
+								}, "Error: Tool parameters were corrupted due to a stream interruption. Please retry.", false);
+								continue;
+							}
 							resolvedTools.push({
 								id: id ?? "",
 								name,
@@ -17359,6 +17858,10 @@ var AnthropicBackend = class {
 								await handleToolResultStreaming(outcome.name, outcome.result, async (results) => {
 									await cb(results, { toolsUsed });
 								});
+								recordToolResult(toolsUsed, {
+									id: outcome.id,
+									name: outcome.name
+								}, resultStr, true);
 								this.pushToolMessages(messages, {
 									id: toolId,
 									name: outcome.name,
@@ -17366,16 +17869,22 @@ var AnthropicBackend = class {
 								}, resultStr);
 							} else {
 								if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
+								const errorMessage = outcome.error instanceof Error ? outcome.error.message : "Unknown error";
 								this.logger.error("[Tool Execution] Tool failed (non-streaming)", {
 									model,
 									toolName: outcome.name,
-									error: outcome.error instanceof Error ? outcome.error.message : "Unknown error"
+									error: errorMessage
 								});
+								const observation = `Error processing ${outcome.name} tool: ${errorMessage}`;
+								recordToolResult(toolsUsed, {
+									id: outcome.id,
+									name: outcome.name
+								}, observation, false);
 								this.pushToolMessages(messages, {
 									id: toolId,
 									name: outcome.name,
 									parameters: outcome.parameters
-								}, `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`);
+								}, observation);
 							}
 						}
 						this.logger.info("[Tool Execution] Making recursive call after tool execution (non-streaming)", {
@@ -17629,7 +18138,7 @@ var AnthropicBackend = class {
 	consolidateSystemMessages(messages) {
 		const systemMessages = messages.filter((m) => m.role === "system");
 		if (systemMessages.length === 0) return void 0;
-		return systemMessages.map((m) => m.content).join("\n");
+		return systemMessages.map((m) => systemContentToText(m.content)).filter((text) => text.trim() !== "").join("\n");
 	}
 	isToolUseEvent(event) {
 		return typeof event === "object" && event !== null && "type" in event && event.type === "tool_use" && "name" in event && "input" in event && "id" in event;
@@ -17772,6 +18281,15 @@ var BaseBedrockBackend = class {
 		const command = new InvokeModelWithResponseStreamCommand(input);
 		return this._bedrockRuntime.send(command, { abortSignal });
 	}
+	/**
+	* The reasoning blocks the just-translated assistant turn produced, cleared as they are
+	* taken. A backend whose provider signs thinking blocks overrides this so the tool loop
+	* below can replay them onto the assistant turns it rebuilds; providers that sign nothing
+	* keep the default. @see AnthropicBedrockBackend.takeReasoningBlocks
+	*/
+	takeReasoningBlocks() {
+		return [];
+	}
 	updateClientForModel(model) {
 		const requiredRegion = this.getRegionForModel(model);
 		this._options.region = requiredRegion;
@@ -17797,8 +18315,14 @@ var BaseBedrockBackend = class {
 			}, callback, toolsUsed);
 			return;
 		}
-		const messagesWithFormat = injectJsonSchemaInstruction(messages, options.responseFormat);
+		let messagesWithFormat = injectJsonSchemaInstruction(messages, options.responseFormat);
 		const bestEffortFormat = isBestEffortJsonSchema(options.responseFormat);
+		if (!options.tools?.length) {
+			if (messagesWithFormat.some((m) => Array.isArray(m.content) && m.content.some((b) => b.type === "tool_use" || b.type === "tool_result"))) {
+				Logger.globalInstance.warn("[BaseBedrockBackend Pre-API #6181] Tool blocks present but no tools offered this turn. Stripping all tool blocks.");
+				messagesWithFormat = stripAllToolBlocks(messagesWithFormat, Logger.globalInstance);
+			}
+		}
 		let formattedMessages = this.formatMessages(messagesWithFormat);
 		let input = this.getPayload(model, formattedMessages, options);
 		const contextWindow = this.getModelContextWindow(model);
@@ -17932,6 +18456,12 @@ var BaseBedrockBackend = class {
 								});
 							} catch {
 								Logger.globalInstance.warn("[BaseBedrockBackend] Tool parameter parse error, skipping tool:", name);
+								const entry = toolsUsed.find((t) => t.name === name && t.id === id);
+								if (entry) entry.arguments = "{}";
+								recordToolResult(toolsUsed, {
+									id,
+									name
+								}, "Error: Tool arguments were malformed and could not be parsed.", false);
 							}
 						}
 						const parallelEnabled = options.parallelToolExecution !== false;
@@ -17959,32 +18489,40 @@ var BaseBedrockBackend = class {
 							parameters: resolvedTools[i].parameters,
 							error: outcome.error
 						});
+						const roundReasoningBlocks = this.takeReasoningBlocks();
 						for (const outcome of outcomes) if (outcome.ok) {
 							await handleToolResultStreaming(outcome.name, outcome.result, async (results) => {
 								await callback(results, buildCompletionInfo());
 							});
+							const resultStr = outcome.result.toString();
+							recordToolResult(toolsUsed, {
+								id: outcome.id,
+								name: outcome.name
+							}, resultStr, true);
 							this.pushToolMessages(messages, {
 								id: outcome.id,
 								name: outcome.name,
 								parameters: outcome.parameters
-							}, outcome.result.toString());
+							}, resultStr, roundReasoningBlocks);
 						} else {
 							if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
 							if (isAbortError(outcome.error)) throw outcome.error;
 							Logger.globalInstance.error(`[BaseBedrockBackend] Tool ${outcome.name} failed:`, outcome.error instanceof Error ? outcome.error.message : String(outcome.error));
+							const errorMessage = outcome.error instanceof Error ? outcome.error.message : "Unknown error";
+							const observation = `Error processing ${outcome.name} tool: ${errorMessage}`;
+							recordToolResult(toolsUsed, {
+								id: outcome.id,
+								name: outcome.name
+							}, observation, false);
 							this.pushToolMessages(messages, {
 								id: outcome.id,
 								name: outcome.name,
 								parameters: outcome.parameters
-							}, `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`);
+							}, observation, roundReasoningBlocks);
 						}
 						await callback(["\n\n"], buildCompletionInfo());
 						await this.complete(model, messages, {
 							...options,
-							thinking: {
-								enabled: false,
-								budget_tokens: 0
-							},
 							tool_choice: "auto",
 							_internal: {
 								...options._internal,
@@ -18028,35 +18566,38 @@ var BaseBedrockBackend = class {
 					if (options.executeTools !== false) {
 						const executable = toolChoices.map((tc) => tc.tool).filter((tool) => tool.id && tool.name && options.tools?.some((o) => o.toolSchema.name === tool.name));
 						if (executable.length > 0) {
+							const roundReasoningBlocks = this.takeReasoningBlocks();
 							for (const { id, name, parameters } of executable) {
 								const toolFn = options.tools?.find((o) => o.toolSchema.name === name)?.toolFn;
 								if (!toolFn) continue;
 								const safeParameters = parameters || "{}";
 								let result;
+								let succeeded = true;
 								try {
 									result = await toolFn(JSON.parse(safeParameters));
 								} catch (err) {
 									if (err instanceof PermissionDeniedError) throw err;
 									if (isAbortError(err)) throw err;
 									Logger.globalInstance.error(`[BaseBedrockBackend] Tool ${name} failed:`, err instanceof Error ? err.message : String(err));
+									succeeded = false;
 									result = `Error processing ${name} tool: ${err instanceof Error ? err.message : "Unknown error"}`;
 								}
 								await handleToolResultStreaming(name, result, async (results) => {
 									await callback(results, buildCompletionInfo());
 								});
+								recordToolResult(toolsUsed, {
+									id,
+									name
+								}, result.toString(), succeeded);
 								this.pushToolMessages(messages, {
 									id,
 									name,
 									parameters
-								}, result.toString());
+								}, result.toString(), roundReasoningBlocks);
 							}
 							await callback(["\n\n"], buildCompletionInfo());
 							await this.complete(model, messages, {
 								...options,
-								thinking: {
-									enabled: false,
-									budget_tokens: 0
-								},
 								tool_choice: "auto",
 								_internal: {
 									...options._internal,
@@ -18151,6 +18692,9 @@ function isToolUseContentBlock(content_block) {
 function isThinkingContentBlock(content_block) {
 	return isRecord(content_block) && content_block.type === "thinking";
 }
+function isRedactedThinkingContentBlock(content_block) {
+	return isRecord(content_block) && content_block.type === "redacted_thinking";
+}
 function isTextDelta(delta) {
 	return isRecord(delta) && delta.type === "text_delta" && "text" in delta;
 }
@@ -18160,6 +18704,9 @@ function isInputJsonDelta(delta) {
 function isThinkingDelta(delta) {
 	return isRecord(delta) && delta.type === "thinking_delta" && "thinking" in delta;
 }
+function isSignatureDelta(delta) {
+	return isRecord(delta) && delta.type === "signature_delta" && "signature" in delta;
+}
 function isMessageStart(chunk) {
 	return isRecord(chunk) && chunk.type === "message_start";
 }
@@ -18187,12 +18734,35 @@ const TEMPERATURE_ONLY_MODELS = [
 ];
 var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 	isInThinkingBlock = false;
+	/**
+	* Reasoning blocks of the assistant turn currently being translated, indexed by the
+	* stream's content-block index. Reset at `message_start` and consumed by
+	* `takeReasoningBlocks` when that turn is rebuilt for a tool continuation.
+	*/
+	assistantReasoningBlocks = [];
 	/** Catalog view of the model being completed; see DispatchModel. */
 	_dispatch = new DispatchModel();
 	setDispatchModel(info) {
 		this._dispatch.set(info);
 	}
 	/**
+	* The reasoning blocks the last translated assistant turn produced, cleared as they
+	* are taken. Anthropic requires a `tool_use` assistant turn to replay its own signed
+	* thinking blocks whenever extended thinking is active on the turn, and an adaptive
+	* model thinks on every turn whether or not the request asked it to - so dropping
+	* them is what makes the synthesis round of a multi-round tool turn come back empty.
+	*
+	* Taken once per provider turn. base.ts takes them before its tool loop and hands the
+	* same array to every assistant message it rebuilds for that round, because a parallel
+	* round splits one provider turn across several synthetic turns and each of them has to
+	* carry the reasoning.
+	*/
+	takeReasoningBlocks() {
+		const blocks = this.assistantReasoningBlocks.filter((b) => b != null);
+		this.assistantReasoningBlocks = [];
+		return blocks;
+	}
+	/**
 	* The record the payload is shaped from: the adapter table first, then the
 	* catalog for a model the table never listed. Table-first keeps every
 	* currently-dispatched Bedrock id on exactly today's payload.
@@ -18609,11 +19179,13 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				content: ""
 			};
 		}).filter((m) => m.content !== "" && (Array.isArray(m.content) ? m.content.length > 0 : true));
-		let systemMessage = messages.filter((m) => m.role === "system" && m.content).map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("\n");
-		if (!options.omitIdentityReminder) {
-			const modelIdentity = `IMPORTANT! Only when someone asks, remember that you are specifically the ${model} model.`;
-			systemMessage = systemMessage ? `${systemMessage}\n${modelIdentity}` : modelIdentity;
-		}
+		const systemBlocks = messages.filter((m) => m.role === "system" && m.content).map((m) => ({
+			text: systemContentToText(m.content),
+			cache: m.cache === true
+		})).filter((block) => block.text.trim() !== "");
+		const identityReminder = options.omitIdentityReminder ? null : `IMPORTANT! Only when someone asks, remember that you are specifically the ${model} model.`;
+		let systemMessage = systemBlocks.map((block) => block.text).join("\n");
+		if (identityReminder) systemMessage = systemMessage ? `${systemMessage}\n${identityReminder}` : identityReminder;
 		const modelId = model.includes(":") || model.startsWith("global.") || model.startsWith("us.") || model.startsWith("anthropic.") ? model : `anthropic.${model}`;
 		const maxTokens = typeof options.maxTokens === "number" ? options.maxTokens : 4096;
 		const body = {
@@ -18621,7 +19193,27 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 			max_tokens: maxTokens,
 			messages: filteredMessages
 		};
-		if (systemMessage) body.system = systemMessage;
+		const cacheStrategy = options.cacheStrategy;
+		const modelSupportsCaching = !BEDROCK_NO_PROMPT_CACHING_MODELS.has(modelId);
+		if (Boolean(cacheStrategy?.enableCaching) && modelSupportsCaching && systemBlocks.some((block) => block.cache)) {
+			const cacheControl = {
+				type: "ephemeral",
+				...cacheStrategy?.cacheTTL === "1h" ? { ttl: cacheStrategy.cacheTTL } : {}
+			};
+			const blocks = systemBlocks.map((block) => block.cache ? {
+				type: "text",
+				text: block.text,
+				cache_control: cacheControl
+			} : {
+				type: "text",
+				text: block.text
+			});
+			if (identityReminder) blocks.push({
+				type: "text",
+				text: identityReminder
+			});
+			body.system = blocks;
+		} else if (systemMessage) body.system = systemMessage;
 		if (options.tools?.length) body.tools = this.formatTools(options.tools);
 		if (typeof options.temperature === "number" && !this.omitsSamplingParams(model)) body.temperature = options.temperature;
 		if (typeof options.topP === "number" && !TEMPERATURE_ONLY_MODELS.includes(model) && !this.omitsSamplingParams(model)) body.top_p = options.topP;
@@ -18649,8 +19241,6 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				topP: options.topP
 			}
 		}, null, 2)}`);
-		const cacheStrategy = options.cacheStrategy;
-		const modelSupportsCaching = !BEDROCK_NO_PROMPT_CACHING_MODELS.has(modelId);
 		if (cacheStrategy?.enableCaching && modelSupportsCaching) {
 			const cachedBody = getCachingAdapter(ModelBackend.Bedrock).applyCaching(body, cacheStrategy);
 			Object.assign(body, cachedBody);
@@ -18674,9 +19264,11 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 	formatMessages(messages) {
 		return messages.reduce((cur, value) => {
 			const previousMessage = cur[cur.length - 1];
-			if (previousMessage && value.role === previousMessage.role) {
-				if (previousMessage.content === value.content) return cur;
-				else if (!Array.isArray(previousMessage.content)) {
+			if (previousMessage && value.role === previousMessage.role && previousMessage.cache !== true) {
+				if (previousMessage.content === value.content) {
+					if (value.cache === true) previousMessage.cache = true;
+					return cur;
+				} else if (!Array.isArray(previousMessage.content)) {
 					const lastIndex = cur.length - 1;
 					const prevContent = typeof cur[lastIndex].content === "string" ? cur[lastIndex].content : "";
 					const currContent = typeof value.content === "string" ? value.content : "";
@@ -18696,6 +19288,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 						});
 						if (contentArray.length > 0) cur[lastIndex].content = contentArray;
 					}
+					if (value.cache === true) cur[lastIndex].cache = true;
 				} else {
 					if (typeof value.content !== "string") {
 						cur.push(value);
@@ -18707,6 +19300,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 						type: "text",
 						text: textContent
 					}];
+					if (value.cache === true) previousMessage.cache = true;
 				}
 				return cur;
 			}
@@ -18717,11 +19311,8 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 	translateChunk(model, chunk) {
 		try {
 			const response = chunk;
-			const thinkingBlocks = response.content.filter((c) => c.type === "thinking");
-			if (thinkingBlocks.length > 0) console.warn(`[AnthropicBedrockBackend] Unexpected thinking blocks in response`, {
-				thinkingBlockCount: thinkingBlocks.length,
-				thinkingLengths: thinkingBlocks.map((b) => b.thinking?.length || 0)
-			});
+			this.assistantReasoningBlocks = response.content.filter((c) => c.type === "thinking" || c.type === "redacted_thinking");
+			if (this.assistantReasoningBlocks.length > 0) console.log(`[AnthropicBedrockBackend] Captured ${this.assistantReasoningBlocks.length} reasoning block(s) for tool continuation`);
 			const textContent = response.content.filter((item) => item.type === "text").map((item) => item.text || "").join("");
 			const toolUseBlocks = response.content.filter((item) => item.type === "tool_use");
 			let choice;
@@ -18775,6 +19366,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 		try {
 			if (isMessageStart(chunk)) {
 				this.isInThinkingBlock = false;
+				this.assistantReasoningBlocks = [];
 				choice = {
 					chunkText: "",
 					usage: {
@@ -18796,8 +19388,12 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				};
 				else if (isThinkingContentBlock(contentBlock)) {
 					this.isInThinkingBlock = true;
+					this.assistantReasoningBlocks[chunk.index] = {
+						...contentBlock,
+						thinking: contentBlock.thinking ?? ""
+					};
 					choice.chunkText = "<think>";
-				}
+				} else if (isRedactedThinkingContentBlock(contentBlock)) this.assistantReasoningBlocks[chunk.index] = { ...contentBlock };
 			} else if (isContentBlockDelta(chunk)) {
 				choice = {
 					status: "stream",
@@ -18807,7 +19403,14 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				const delta = chunk.delta;
 				if (isTextDelta(delta)) choice.chunkText = delta.text;
 				else if (isInputJsonDelta(delta)) choice.chunkText = delta.partial_json;
-				else if (isThinkingDelta(delta)) choice.chunkText = delta.thinking;
+				else if (isThinkingDelta(delta)) {
+					choice.chunkText = delta.thinking;
+					const block = this.assistantReasoningBlocks[chunk.index];
+					if (block?.type === "thinking") block.thinking += delta.thinking;
+				} else if (isSignatureDelta(delta)) {
+					const block = this.assistantReasoningBlocks[chunk.index];
+					if (block?.type === "thinking") block.signature = delta.signature;
+				}
 			} else if (isContentBlockStop(chunk)) {
 				choice = {
 					status: "stream",
@@ -18866,7 +19469,8 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 			name: tool.name,
 			input: JSON.parse(tool.parameters || "{}")
 		};
-		const assistantContent = thinkingBlocks && thinkingBlocks.length > 0 ? [...thinkingBlocks, toolUseBlock] : [toolUseBlock];
+		const reasoningBlocks = thinkingBlocks?.length ? thinkingBlocks : this.takeReasoningBlocks();
+		const assistantContent = reasoningBlocks.length > 0 ? [...reasoningBlocks, toolUseBlock] : [toolUseBlock];
 		messages.push({
 			role: "assistant",
 			content: assistantContent
@@ -19998,7 +20602,7 @@ var BFLBackend = class {
 					input: 400,
 					output: 400
 				} },
-				description: "FLUX Kontext Pro - Advanced image-to-image transformation with high-quality output and versatile editing capabilities.",
+				description: "FLUX Pro 1.1 - Professional quality image generation with strong prompt adherence and fast turnaround.",
 				supportsSafetyTolerance: true,
 				rank: 1
 			},
@@ -20064,7 +20668,7 @@ var BFLBackend = class {
 					input: 350,
 					output: 350
 				} },
-				description: "FLUX Kontext Max - Premium image-to-image transformation with maximum quality and advanced editing capabilities.",
+				description: "FLUX Kontext Pro - Advanced image-to-image transformation with high-quality output and versatile editing capabilities.",
 				supportsSafetyTolerance: true,
 				rank: 4
 			},
@@ -20080,7 +20684,7 @@ var BFLBackend = class {
 					input: 450,
 					output: 450
 				} },
-				description: "BlackForest Labs FLUX Kontext Max - Premium image-to-image transformation with maximum quality and capabilities",
+				description: "FLUX Kontext Max - Premium image-to-image transformation with maximum quality and capabilities.",
 				supportsSafetyTolerance: true,
 				rank: 5
 			}
@@ -20538,6 +21142,7 @@ var GeminiBackend = class {
 		const toolCallCount = options._internal?.toolCallCount ?? 0;
 		const accumInputTokens = options._internal?.accumInputTokens ?? 0;
 		const accumOutputTokens = options._internal?.accumOutputTokens ?? 0;
+		const liveToolUseIds = new Set(options._internal?.liveToolUseIds ?? []);
 		const maxToolCalls = options._internal?.maxToolCalls ?? 10;
 		if (toolCallCount >= maxToolCalls && options.tools?.length) {
 			this.logger.warn(`[Gemini] Max tool calls limit (${maxToolCalls}) reached. Disabling tools to prevent infinite loops.`);
@@ -20552,7 +21157,7 @@ var GeminiBackend = class {
 		const bestEffortFormat = isBestEffortJsonSchema(options.responseFormat);
 		const systemInstruction = messagesWithFormat.filter((message) => message.role === "system").map((message) => message.content).join("\n");
 		const nonsystemMessages = messagesWithFormat.filter((message) => message.role !== "system");
-		const contents = this.formatMessagesIntoGeminiContent(nonsystemMessages);
+		const contents = this.formatMessagesIntoGeminiContent(nonsystemMessages, liveToolUseIds);
 		const generationConfig = this.getGenerationConfig(modelInfo, options);
 		const tools = !options.tools?.length ? void 0 : [{ functionDeclarations: options.tools.map((tool) => {
 			const params = pick(tool.toolSchema.parameters, "type", "properties", "required");
@@ -20679,22 +21284,32 @@ var GeminiBackend = class {
 						await handleToolResultStreaming(outcome.toolCall.name, outcome.result, async (results) => {
 							await callback(results, { toolsUsed });
 						});
+						const resultContent = JSON.stringify({ result: outcome.result });
+						recordToolResult(toolsUsed, {
+							id: outcome.toolCall.id,
+							name: outcome.toolCall.name
+						}, resultContent, true);
 						messages.push({
 							role: "tool",
 							content: [{
 								type: "tool_result",
-								content: JSON.stringify({ result: outcome.result }),
+								content: resultContent,
 								tool_use_id: outcome.toolCall.id
 							}]
 						});
 					} else {
 						if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
 						this.logger.error(`[Gemini] Error executing tool ${outcome.toolCall.name}:`, outcome.error);
+						const errorContent = JSON.stringify({ error: outcome.error instanceof Error ? outcome.error.message : "Unknown error" });
+						recordToolResult(toolsUsed, {
+							id: outcome.toolCall.id,
+							name: outcome.toolCall.name
+						}, errorContent, false);
 						messages.push({
 							role: "tool",
 							content: [{
 								type: "tool_result",
-								content: JSON.stringify({ error: outcome.error instanceof Error ? outcome.error.message : "Unknown error" }),
+								content: errorContent,
 								tool_use_id: outcome.toolCall.id
 							}]
 						});
@@ -20706,7 +21321,8 @@ var GeminiBackend = class {
 							...options._internal,
 							toolCallCount: toolCallCount + 1,
 							accumInputTokens: accumInputTokens + turnInputTokens,
-							accumOutputTokens: accumOutputTokens + turnOutputTokens
+							accumOutputTokens: accumOutputTokens + turnOutputTokens,
+							liveToolUseIds: [...liveToolUseIds, ...toolCalls.map((tc) => tc.id)]
 						}
 					}, callback, toolsUsed);
 				} else {
@@ -20805,22 +21421,32 @@ var GeminiBackend = class {
 					await handleToolResultStreaming(outcome.toolCall.name, outcome.result, async (results) => {
 						await callback(results, { toolsUsed });
 					});
+					const resultContent = JSON.stringify({ result: outcome.result });
+					recordToolResult(toolsUsed, {
+						id: outcome.toolCall.id,
+						name: outcome.toolCall.name
+					}, resultContent, true);
 					messages.push({
 						role: "tool",
 						content: [{
 							type: "tool_result",
-							content: JSON.stringify({ result: outcome.result }),
+							content: resultContent,
 							tool_use_id: outcome.toolCall.id
 						}]
 					});
 				} else {
 					if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
 					this.logger.error(`[Gemini] Error executing tool ${outcome.toolCall.name}:`, outcome.error);
+					const errorContent = JSON.stringify({ error: outcome.error instanceof Error ? outcome.error.message : "Unknown error" });
+					recordToolResult(toolsUsed, {
+						id: outcome.toolCall.id,
+						name: outcome.toolCall.name
+					}, errorContent, false);
 					messages.push({
 						role: "tool",
 						content: [{
 							type: "tool_result",
-							content: JSON.stringify({ error: outcome.error instanceof Error ? outcome.error.message : "Unknown error" }),
+							content: errorContent,
 							tool_use_id: outcome.toolCall.id
 						}]
 					});
@@ -20832,7 +21458,8 @@ var GeminiBackend = class {
 						...options._internal,
 						toolCallCount: toolCallCount + 1,
 						accumInputTokens: accumInputTokens + turnInputTokens,
-						accumOutputTokens: accumOutputTokens + turnOutputTokens
+						accumOutputTokens: accumOutputTokens + turnOutputTokens,
+						liveToolUseIds: [...liveToolUseIds, ...toolCalls.map((tc) => tc.id)]
 					}
 				}, callback, toolsUsed);
 			} else {
@@ -20841,8 +21468,9 @@ var GeminiBackend = class {
 			}
 		}
 	}
-	formatMessagesIntoGeminiContent(messages) {
+	formatMessagesIntoGeminiContent(messages, liveToolUseIds) {
 		const toolUseIdToName = /* @__PURE__ */ new Map();
+		const droppedToolUseIds = /* @__PURE__ */ new Set();
 		return messages.map((message) => {
 			const mapRole = (role) => {
 				switch (role) {
@@ -20856,25 +21484,41 @@ var GeminiBackend = class {
 				role: mapRole(message.role),
 				parts: [{ text: message.content }]
 			};
-			if (message.content?.[0].type === "text") return {
+			const hasToolUse = Array.isArray(message.content) && message.content.some((item) => item.type === "tool_use");
+			if (!hasToolUse && message.content?.[0].type === "text") return {
 				role: mapRole(message.role),
 				parts: [{ text: (message.content?.[0]).text }]
 			};
-			if (message.content?.[0].type === "image") return {
+			if (!hasToolUse && message.content?.[0].type === "image") return {
 				role: mapRole(message.role),
 				parts: [{ inlineData: {
 					mimeType: (message.content?.[0]).source.media_type,
 					data: (message.content?.[0]).source.data
 				} }]
 			};
-			if (message.content?.[0].type === "tool_use") {
-				const parts = message.content.filter((item) => item.type === "tool_use").map((toolUse, index) => {
+			if (hasToolUse) {
+				const toolUseBlocks = message.content.filter((item) => item.type === "tool_use");
+				const textParts = message.content.filter((item) => item.type === "text").map((item) => ({ text: item.text }));
+				if (!toolUseBlocks.some((t) => liveToolUseIds.has(t.id)) && /^gemini-3(\D|$)/.test(this.currentModel) && !toolUseBlocks[0]?.thought_signature) {
+					this.logger.warn("[Gemini] Dropping replayed tool_use block(s) with no thought_signature on the first call:", {
+						names: toolUseBlocks.map((t) => t.name),
+						messageRole: message.role
+					});
+					toolUseBlocks.forEach((t) => droppedToolUseIds.add(t.id));
+					if (textParts.length === 0) return null;
+					return {
+						role: mapRole(message.role),
+						parts: textParts
+					};
+				}
+				const parts = [...textParts];
+				parts.push(...toolUseBlocks.map((toolUse, index) => {
 					toolUseIdToName.set(toolUse.id, toolUse.name);
 					const part = { functionCall: {
 						name: toolUse.name,
 						args: toolUse.input
 					} };
-					if (index === 0 && toolUse.thought_signature) {
+					if (index === 0) if (toolUse.thought_signature) {
 						part.thoughtSignature = toolUse.thought_signature;
 						part.thought_signature = toolUse.thought_signature;
 						this.logger.debug("[Gemini] Including thought_signature in request (both formats):", {
@@ -20882,29 +21526,26 @@ var GeminiBackend = class {
 							id: toolUse.id,
 							position: "first"
 						});
-					} else if (index === 0 && !toolUse.thought_signature) {
-						this.logger.warn("[Gemini] Missing thought_signature for first function call:", {
-							name: toolUse.name,
-							id: toolUse.id,
-							messageRole: message.role
-						});
-						this.logger.warn("[Gemini] This may cause a 400 error with Gemini 3 Pro");
-					}
+					} else this.logger.warn("[Gemini] Missing thought_signature for first function call:", {
+						name: toolUse.name,
+						id: toolUse.id
+					});
 					return part;
-				});
+				}));
 				return {
 					role: mapRole(message.role),
 					parts
 				};
 			}
 			if (message.content?.[0].type === "tool_result") {
-				const toolResult = message.content[0];
+				const parts = message.content.filter((item) => item.type === "tool_result").filter((toolResult) => !droppedToolUseIds.has(toolResult.tool_use_id)).map((toolResult) => ({ functionResponse: {
+					name: toolUseIdToName.get(toolResult.tool_use_id) ?? toolResult.tool_use_id,
+					response: { result: toolResult.content }
+				} }));
+				if (parts.length === 0) return null;
 				return {
 					role: mapRole(message.role),
-					parts: [{ functionResponse: {
-						name: toolUseIdToName.get(toolResult.tool_use_id) ?? toolResult.tool_use_id,
-						response: { result: (message.content?.[0]).content }
-					} }]
+					parts
 				};
 			}
 			return null;
@@ -20991,6 +21632,54 @@ var GeminiBackend = class {
 	}
 };
 /**
+* The cache-inclusive-to-cache-exclusive conversion, shared by every adapter whose
+* provider reports cached tokens as a SUBSET of the prompt count.
+*
+* getTextModelCost expects Anthropic's convention: `inputTokens` counts only uncached
+* tokens and cache reads bill separately at their own (much cheaper) rate. Anthropic
+* and Claude-on-Bedrock deliver that natively. OpenAI and Moonshot do not - their
+* prompt total already CONTAINS the cached tokens - so those adapters must subtract
+* here before forwarding, or settlement double-bills the cached portion.
+*
+* Must stay in sync with the disjoint-fields assumption documented at the settlement
+* site in ChatCompletionProcess.
+*/
+/**
+* Split a cache-INCLUSIVE prompt total into the disjoint pair CompletionInfo carries.
+*
+* Forwarding the cached count without subtracting double-bills it; forwarding nothing
+* charges the full input rate on tokens the provider billed at a fraction of it.
+* Subtracting is the only split that bills what the provider actually charged.
+*
+* Clamped at zero: if a feed ever reports more cached than prompt tokens, a negative
+* input count would silently credit the user.
+*/
+function splitCacheInclusiveInput(totalPromptTokens, cacheReadTokens) {
+	if (cacheReadTokens <= 0) return { inputTokens: totalPromptTokens };
+	const cached = Math.min(cacheReadTokens, totalPromptTokens);
+	return {
+		inputTokens: Math.max(0, totalPromptTokens - cached),
+		cacheReadInputTokens: cached
+	};
+}
+/**
+* Cached prompt tokens from a raw provider usage object, across every spelling in use:
+* OpenAI Chat Completions nests them under `prompt_tokens_details`, the OpenAI
+* Responses API under `input_tokens_details`, and Moonshot publishes a flat
+* `cached_tokens` alongside the OpenAI-shaped nesting. Reading only one spelling
+* silently bills every cache hit on the other transports at the full input rate.
+*/
+function cachedTokensFromUsage(usage) {
+	if (!usage) return 0;
+	const candidates = [
+		usage.cached_tokens,
+		usage.prompt_tokens_details?.cached_tokens,
+		usage.input_tokens_details?.cached_tokens
+	];
+	for (const value of candidates) if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+	return 0;
+}
+/**
 * Request shaping for Moonshot's Kimi models. Kept separate from kimiBackend's
 * transport so every "which parameter does this id accept" rule is one pure
 * function with a test, rather than a conditional buried in a 400-line complete().
@@ -21379,7 +22068,7 @@ var KimiBackend = class {
 		if (!(response instanceof Stream)) {
 			const streamedText = [];
 			if (!response.choices || response.choices.length === 0) throw new Error("No choices returned from the Moonshot API");
-			const turnCacheReadTokens = this.cachedTokensOf(response.usage);
+			const turnCacheReadTokens = cachedTokensFromUsage(response.usage);
 			for (const c of response.choices) {
 				if (!c.message) continue;
 				const reasoningContent = c.message.reasoning_content;
@@ -21411,6 +22100,10 @@ var KimiBackend = class {
 								this.logger.warn(`JSON parse error for ${toolCall.function.name} arguments`);
 								const entry = toolsUsed.find((t) => t.name === toolCall.function.name && t.id === toolCall.id);
 								if (entry) entry.arguments = "{}";
+								recordToolResult(toolsUsed, {
+									id: toolCall.id,
+									name: toolCall.function.name
+								}, "Error: Tool arguments were malformed and could not be parsed.", false);
 							}
 						}
 						const parallelEnabled = options.parallelToolExecution !== false;
@@ -21438,18 +22131,30 @@ var KimiBackend = class {
 							parameters: resolvedTools[i].parameters,
 							error: outcome.error
 						});
-						for (const outcome of outcomes) if (outcome.ok) this.pushToolMessages(messages, {
-							id: outcome.id,
-							name: outcome.name,
-							parameters: outcome.parameters
-						}, outcome.result.toString());
-						else {
+						for (const outcome of outcomes) if (outcome.ok) {
+							const resultStr = outcome.result.toString();
+							recordToolResult(toolsUsed, {
+								id: outcome.id,
+								name: outcome.name
+							}, resultStr, true);
+							this.pushToolMessages(messages, {
+								id: outcome.id,
+								name: outcome.name,
+								parameters: outcome.parameters
+							}, resultStr);
+						} else {
 							if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
+							const errorMessage = outcome.error instanceof Error ? outcome.error.message : "Unknown error";
+							const observation = `Error processing ${outcome.name} tool: ${errorMessage}`;
+							recordToolResult(toolsUsed, {
+								id: outcome.id,
+								name: outcome.name
+							}, observation, false);
 							this.pushToolMessages(messages, {
 								id: outcome.id,
 								name: outcome.name,
 								parameters: outcome.parameters
-							}, `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`);
+							}, observation);
 						}
 						await this.complete(model, messages, {
 							...options,
@@ -21465,7 +22170,7 @@ var KimiBackend = class {
 					} else {
 						this.logger.debug(`[Tool Execution] executeTools=false, passing tool calls to callback`);
 						await callback([null], {
-							...this.splitCachedInput(accumInputTokens + (response.usage?.prompt_tokens || 0), accumCacheReadTokens + turnCacheReadTokens),
+							...splitCacheInclusiveInput(accumInputTokens + (response.usage?.prompt_tokens || 0), accumCacheReadTokens + turnCacheReadTokens),
 							outputTokens: accumOutputTokens + (response.usage?.completion_tokens || 0),
 							toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
 						});
@@ -21488,7 +22193,7 @@ var KimiBackend = class {
 			const finishReason = normalizeOpenAIFinishReason(response.choices[0]?.finish_reason);
 			const totalCacheReadTokens = accumCacheReadTokens + turnCacheReadTokens;
 			await callback(streamedText, {
-				...this.splitCachedInput(accumInputTokens + (response.usage?.prompt_tokens || 0), totalCacheReadTokens),
+				...splitCacheInclusiveInput(accumInputTokens + (response.usage?.prompt_tokens || 0), totalCacheReadTokens),
 				outputTokens: accumOutputTokens + (response.usage?.completion_tokens || 0),
 				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
 				cacheStats,
@@ -21507,7 +22212,7 @@ var KimiBackend = class {
 			if (chunk.usage) {
 				inputTokens = Math.max(inputTokens, chunk.usage?.prompt_tokens || 0);
 				outputTokens += chunk.usage?.completion_tokens || 0;
-				const chunkCached = this.cachedTokensOf(chunk.usage);
+				const chunkCached = cachedTokensFromUsage(chunk.usage);
 				if (chunkCached > 0) cachedTokensFromStream = chunkCached;
 			}
 			chunk?.choices.forEach((c) => {
@@ -21537,7 +22242,7 @@ var KimiBackend = class {
 			if (streamedText.some((t) => t)) sawAnyText = true;
 			const normalizedFinishReason = normalizeOpenAIFinishReason(streamFinishReason);
 			await callback(streamedText, {
-				...this.splitCachedInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
+				...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 				outputTokens: accumOutputTokens + outputTokens,
 				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
 				...normalizedFinishReason ? { stopReason: normalizedFinishReason } : {}
@@ -21545,7 +22250,7 @@ var KimiBackend = class {
 		}
 		if (isInThinkingBlock) {
 			await callback(["</think>"], {
-				...this.splitCachedInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
+				...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 				outputTokens: accumOutputTokens + outputTokens,
 				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
 			});
@@ -21562,7 +22267,7 @@ var KimiBackend = class {
 			if (cacheStats) logCacheStats(this.logger, cacheStats, { streaming: true });
 		}
 		if (nativeFormat && func.length === 0) await callback([], {
-			...this.splitCachedInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
+			...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 			outputTokens: accumOutputTokens + outputTokens,
 			toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
 			responseFormatMode: "native",
@@ -21598,6 +22303,10 @@ var KimiBackend = class {
 						this.logger.warn(`JSON parse error for ${name} arguments (streaming)`);
 						const entry = toolsUsed.find((t) => t.name === name && t.id === id);
 						if (entry) entry.arguments = "{}";
+						recordToolResult(toolsUsed, {
+							id,
+							name
+						}, "Error: Tool arguments were malformed and could not be parsed.", false);
 					}
 				}
 				const parallelEnabled = options.parallelToolExecution !== false;
@@ -21625,18 +22334,30 @@ var KimiBackend = class {
 					parameters: resolvedTools[i].parameters,
 					error: outcome.error
 				});
-				for (const outcome of outcomes) if (outcome.ok) this.pushToolMessages(messages, {
-					id: outcome.id,
-					name: outcome.name,
-					parameters: outcome.parameters
-				}, outcome.result.toString());
-				else {
+				for (const outcome of outcomes) if (outcome.ok) {
+					const resultStr = outcome.result.toString();
+					recordToolResult(toolsUsed, {
+						id: outcome.id,
+						name: outcome.name
+					}, resultStr, true);
+					this.pushToolMessages(messages, {
+						id: outcome.id,
+						name: outcome.name,
+						parameters: outcome.parameters
+					}, resultStr);
+				} else {
 					if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
+					const errorMessage = outcome.error instanceof Error ? outcome.error.message : "Unknown error";
+					const observation = `Error processing ${outcome.name} tool: ${errorMessage}`;
+					recordToolResult(toolsUsed, {
+						id: outcome.id,
+						name: outcome.name
+					}, observation, false);
 					this.pushToolMessages(messages, {
 						id: outcome.id,
 						name: outcome.name,
 						parameters: outcome.parameters
-					}, `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`);
+					}, observation);
 				}
 				await this.complete(model, messages, {
 					...options,
@@ -21651,52 +22372,13 @@ var KimiBackend = class {
 			} else {
 				this.logger.debug(`[Tool Execution] executeTools=false, passing tool calls to callback`);
 				await callback([null], {
-					...this.splitCachedInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
+					...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 					outputTokens: accumOutputTokens + outputTokens,
 					toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
 				});
 			}
 		}
 	}
-	/**
-	* Convert Moonshot's CACHE-INCLUSIVE `prompt_tokens` into the cache-EXCLUSIVE
-	* convention getTextModelCost expects, which is Anthropic's: `inputTokens`
-	* counts only uncached tokens and cache reads are billed separately at their
-	* own (much cheaper) rate.
-	*
-	* Verified live 2026-07-28: a repeated 1220-token prompt returned
-	* `prompt_tokens: 1220` WITH `cached_tokens: 1220` - the same tokens, reported
-	* twice, not 1220 fresh plus 1220 cached. So passing prompt_tokens through as
-	* inputTokens while also forwarding cacheReadInputTokens would bill the cached
-	* portion twice; passing it through and forwarding NOTHING (the previous
-	* behavior) charges the full input rate on tokens Moonshot billed at roughly a
-	* sixth of it - on k2.6, $0.95/MTok against $0.16. Subtracting is the only
-	* split that bills what the provider actually charged.
-	*
-	* Clamped at zero: if a feed ever reports more cached than prompt tokens, a
-	* negative input count would silently credit the user.
-	*/
-	splitCachedInput(totalPromptTokens, cacheReadTokens) {
-		if (cacheReadTokens <= 0) return { inputTokens: totalPromptTokens };
-		const cached = Math.min(cacheReadTokens, totalPromptTokens);
-		return {
-			inputTokens: Math.max(0, totalPromptTokens - cached),
-			cacheReadInputTokens: cached
-		};
-	}
-	/**
-	* Cached prompt tokens from a usage object. Moonshot publishes BOTH a flat
-	* `usage.cached_tokens` and the nested OpenAI `prompt_tokens_details.cached_tokens`
-	* - confirmed live, both present with the same value - so either spelling is
-	* accepted and reading neither would bill every hit at the full input rate.
-	*/
-	cachedTokensOf(usage) {
-		if (!usage) return 0;
-		const flat = usage.cached_tokens;
-		if (typeof flat === "number" && Number.isFinite(flat) && flat >= 0) return flat;
-		const nested = usage.prompt_tokens_details?.cached_tokens;
-		return typeof nested === "number" && Number.isFinite(nested) && nested >= 0 ? nested : 0;
-	}
 	formatMessages(messages) {
 		return convertMessagesToOpenAIFormat(messages);
 	}
@@ -22001,7 +22683,7 @@ var OllamaBackend = class OllamaBackend {
 				name: tc.name,
 				parameters: tc.arguments || "{}"
 			}, `Error: tool "${tc.name}" is not available. Do not call it again; answer directly or use a listed tool.`);
-			(await executeToolsBatch(resolved.map(({ tc, toolFn }) => async () => {
+			const outcomes = await executeToolsBatch(resolved.map(({ tc, toolFn }) => async () => {
 				let params = {};
 				try {
 					params = JSON.parse(tc.arguments || "{}");
@@ -22011,17 +22693,22 @@ var OllamaBackend = class OllamaBackend {
 			}), {
 				parallel: options.parallelToolExecution !== false,
 				maxConcurrency: options.maxParallelTools
-			})).forEach((outcome, i) => {
+			});
+			const observations = [];
+			outcomes.forEach((outcome, i) => {
 				const { tc } = resolved[i];
 				const params = tc.arguments || "{}";
-				if (outcome.ok) this.pushToolMessages(messages, {
-					id: tc.id,
-					name: tc.name,
-					parameters: params
-				}, outcome.result);
-				else {
+				if (outcome.ok) {
+					observations[i] = outcome.result;
+					this.pushToolMessages(messages, {
+						id: tc.id,
+						name: tc.name,
+						parameters: params
+					}, outcome.result);
+				} else {
 					if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
 					const errorMsg = `Error running ${tc.name}: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`;
+					observations[i] = errorMsg;
 					this.pushToolMessages(messages, {
 						id: tc.id,
 						name: tc.name,
@@ -22029,10 +22716,12 @@ var OllamaBackend = class OllamaBackend {
 					}, errorMsg);
 				}
 			});
-			const executedToolsUsed = [...priorToolsUsed, ...resolved.map(({ tc }) => ({
+			const executedToolsUsed = [...priorToolsUsed, ...resolved.map(({ tc }, i) => ({
 				name: tc.name,
 				arguments: tc.arguments,
-				id: tc.id
+				id: tc.id,
+				returnValue: truncateToolResult(String(observations[i])),
+				success: outcomes[i].ok
 			}))];
 			if (options.abortSignal?.aborted) {
 				await callback([""], {
@@ -22140,12 +22829,21 @@ var OllamaBackend = class OllamaBackend {
 			}
 		};
 	}
-	/** Normalize Ollama's native tool_calls into the shared NormalizedToolCall shape. */
+	/**
+	* Normalize Ollama's native tool_calls into the shared NormalizedToolCall shape.
+	*
+	* Ids are real uuids, not a position-derived string. A prior version keyed ids off
+	* `accumulated-count + round-local-index`, but the accumulated count is measured AFTER
+	* hallucinated calls are filtered out while the round-local index is assigned BEFORE that
+	* filter runs, so the two can drift and mint the same id for two different real calls across
+	* rounds - replayableToolCalls dedupes by id and silently drops the later one. A uuid makes
+	* the whole collision class unrepresentable, matching how the other backends already mint ids.
+	*/
 	normalizeToolCalls(toolCalls) {
-		return toolCalls.map((tc, i) => ({
+		return toolCalls.map((tc) => ({
 			name: tc.function.name,
 			arguments: JSON.stringify(tc.function.arguments ?? {}),
-			id: `ollama-tool-${i}-${tc.function.name}`
+			id: `ollama-tool-${v4()}`
 		}));
 	}
 	/**
@@ -22183,7 +22881,7 @@ var OllamaBackend = class OllamaBackend {
 			seen.add(key);
 			calls.push({
 				...call,
-				id: `ollama-content-tool-${calls.length}-${call.name}`
+				id: `ollama-content-tool-${v4()}`
 			});
 		}
 		return calls;
@@ -22432,7 +23130,8 @@ var OpenAIBackend = class {
 				can_stream: true,
 				pricing: { 1047576: {
 					input: 2 / 1e6,
-					output: 8 / 1e6
+					output: 8 / 1e6,
+					cache_read: .5 / 1e6
 				} },
 				supportsVision: true,
 				supportsTools: true,
@@ -22452,7 +23151,8 @@ var OpenAIBackend = class {
 				can_stream: true,
 				pricing: { 1047576: {
 					input: .4 / 1e6,
-					output: 1.6 / 1e6
+					output: 1.6 / 1e6,
+					cache_read: .1 / 1e6
 				} },
 				supportsVision: true,
 				supportsTools: true,
@@ -22472,7 +23172,8 @@ var OpenAIBackend = class {
 				can_stream: true,
 				pricing: { 1047576: {
 					input: .1 / 1e6,
-					output: .4 / 1e6
+					output: .4 / 1e6,
+					cache_read: .025 / 1e6
 				} },
 				supportsVision: true,
 				supportsTools: true,
@@ -22535,7 +23236,8 @@ var OpenAIBackend = class {
 				can_stream: true,
 				pricing: { 2e5: {
 					input: 2 / 1e6,
-					output: 8 / 1e6
+					output: 8 / 1e6,
+					cache_read: .5 / 1e6
 				} },
 				supportsVision: true,
 				supportsTools: true,
@@ -22621,7 +23323,8 @@ var OpenAIBackend = class {
 				can_think: true,
 				pricing: { 2e5: {
 					input: 1.1 / 1e6,
-					output: 4.4 / 1e6
+					output: 4.4 / 1e6,
+					cache_read: .275 / 1e6
 				} },
 				supportsVision: true,
 				supportsImageVariation: false,
@@ -22997,7 +23700,8 @@ var OpenAIBackend = class {
 				can_stream: true,
 				pricing: { 8e3: {
 					input: 2.5 / 1e6,
-					output: 10 / 1e6
+					output: 10 / 1e6,
+					cache_read: 1.25 / 1e6
 				} },
 				supportsVision: true,
 				supportsImageVariation: false,
@@ -23016,7 +23720,8 @@ var OpenAIBackend = class {
 				can_stream: true,
 				pricing: { 8e3: {
 					input: .15 / 1e6,
-					output: .6 / 1e6
+					output: .6 / 1e6,
+					cache_read: .075 / 1e6
 				} },
 				supportsVision: true,
 				supportsImageVariation: false,
@@ -23207,6 +23912,7 @@ var OpenAIBackend = class {
 		const toolCallCount = options._internal?.toolCallCount ?? 0;
 		const accumInputTokens = options._internal?.accumInputTokens ?? 0;
 		const accumOutputTokens = options._internal?.accumOutputTokens ?? 0;
+		const accumCacheReadTokens = options._internal?.accumCacheReadTokens ?? 0;
 		const maxToolCalls = options._internal?.maxToolCalls ?? 10;
 		if (toolCallCount >= maxToolCalls && options.tools?.length) {
 			this.logger.warn(`⚠️ Max tool calls limit (${maxToolCalls}) reached. Disabling tools to prevent infinite loops.`);
@@ -23296,6 +24002,7 @@ var OpenAIBackend = class {
 		let outputTokens = 0;
 		if (!(response instanceof Stream)) {
 			const streamedText = [];
+			const totalCacheReadTokens = accumCacheReadTokens + cachedTokensFromUsage(response.usage);
 			if (!response.choices || response.choices.length === 0) throw new Error("No choices returned from OpenAI API");
 			for (const c of response.choices) {
 				if (!c.message) continue;
@@ -23329,6 +24036,10 @@ var OpenAIBackend = class {
 								this.logger.warn(`JSON parse error for ${toolCall.function.name} arguments`);
 								const entry = toolsUsed.find((t) => t.name === toolCall.function.name && t.id === toolCall.id);
 								if (entry) entry.arguments = "{}";
+								recordToolResult(toolsUsed, {
+									id: toolCall.id,
+									name: toolCall.function.name
+								}, "Error: Tool arguments were malformed and could not be parsed.", false);
 							}
 						}
 						const parallelEnabled = options.parallelToolExecution !== false;
@@ -23365,6 +24076,10 @@ var OpenAIBackend = class {
 								if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
 								const errorMsg = `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`;
 								streamedText[c.index] = errorMsg;
+								recordToolResult(toolsUsed, {
+									id: outcome.id,
+									name: outcome.name
+								}, errorMsg, false);
 								this.pushToolMessages(messages, {
 									id: outcome.id,
 									name: outcome.name,
@@ -23385,6 +24100,10 @@ var OpenAIBackend = class {
 								});
 							});
 							const sanitizedResult = thisToolHadArtifact ? resultStr.replace(/<artifact(?:\s[^>]*)?>[\s\S]*?<\/artifact>/gi, "[Artifact rendered and delivered to user]") : resultStr;
+							recordToolResult(toolsUsed, {
+								id: outcome.id,
+								name: outcome.name
+							}, sanitizedResult, true);
 							this.pushToolMessages(messages, {
 								id: outcome.id,
 								name: outcome.name,
@@ -23408,7 +24127,8 @@ var OpenAIBackend = class {
 								...options._internal,
 								toolCallCount: toolCallCount + 1,
 								accumInputTokens: accumInputTokens + (response.usage?.prompt_tokens || 0),
-								accumOutputTokens: accumOutputTokens + (response.usage?.completion_tokens || 0)
+								accumOutputTokens: accumOutputTokens + (response.usage?.completion_tokens || 0),
+								accumCacheReadTokens: totalCacheReadTokens
 							}
 						}, recursiveCallback, toolsUsed);
 						if (anyArtifactWasStreamed && recursiveBuffer) {
@@ -23419,7 +24139,7 @@ var OpenAIBackend = class {
 					} else {
 						this.logger.debug(`[Tool Execution] executeTools=false, passing tool calls to callback`);
 						await callback([null], {
-							inputTokens: accumInputTokens + (response.usage?.prompt_tokens || 0),
+							...splitCacheInclusiveInput(accumInputTokens + (response.usage?.prompt_tokens || 0), totalCacheReadTokens),
 							outputTokens: accumOutputTokens + (response.usage?.completion_tokens || 0),
 							toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
 						});
@@ -23435,7 +24155,7 @@ var OpenAIBackend = class {
 			}
 			const finishReason = normalizeOpenAIFinishReason(response.choices[0]?.finish_reason);
 			await callback(streamedText, {
-				inputTokens: accumInputTokens + (response.usage?.prompt_tokens || 0),
+				...splitCacheInclusiveInput(accumInputTokens + (response.usage?.prompt_tokens || 0), totalCacheReadTokens),
 				outputTokens: accumOutputTokens + (response.usage?.completion_tokens || 0),
 				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
 				cacheStats,
@@ -23463,7 +24183,7 @@ var OpenAIBackend = class {
 				inputTokens = Math.max(inputTokens, chunk.usage?.prompt_tokens || 0);
 				outputTokens += chunk.usage?.completion_tokens || 0;
 				if (chunk.usage.prompt_tokens_details?.cached_tokens !== void 0) {
-					cachedTokensFromStream = chunk.usage.prompt_tokens_details.cached_tokens;
+					cachedTokensFromStream = Math.max(cachedTokensFromStream, chunk.usage.prompt_tokens_details.cached_tokens);
 					if (cachedTokensFromStream > 0) this.logger.debug("[OpenAI] Captured cached tokens", { cachedTokens: cachedTokensFromStream });
 					else this.logger.debug("[OpenAI] No cached tokens in chunk", { note: "possible cache miss or first request" });
 				}
@@ -23480,7 +24200,7 @@ var OpenAIBackend = class {
 			});
 			const normalizedFinishReason = normalizeOpenAIFinishReason(streamFinishReason);
 			await callback(streamedText, {
-				inputTokens: accumInputTokens + inputTokens,
+				...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 				outputTokens: accumOutputTokens + outputTokens,
 				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
 				...normalizedFinishReason ? { stopReason: normalizedFinishReason } : {}
@@ -23510,7 +24230,7 @@ var OpenAIBackend = class {
 			if (cacheStats) logCacheStats(this.logger, cacheStats, { streaming: true });
 		}
 		if ((isO1Model || func.length === 0) && options.responseFormat?.type === "json_schema") await callback([], {
-			inputTokens: accumInputTokens + inputTokens,
+			...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 			outputTokens: accumOutputTokens + outputTokens,
 			toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
 			cacheStats,
@@ -23548,6 +24268,10 @@ var OpenAIBackend = class {
 						});
 						const entry = toolsUsed.find((t) => t.name === name && t.id === id);
 						if (entry) entry.arguments = "{}";
+						recordToolResult(toolsUsed, {
+							id,
+							name
+						}, "Error: Tool arguments were malformed and could not be parsed.", false);
 					}
 				}
 				const parallelEnabled = options.parallelToolExecution !== false;
@@ -23582,11 +24306,16 @@ var OpenAIBackend = class {
 				for (const outcome of outcomes) {
 					if (!outcome.ok) {
 						if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
+						const errorMsg = `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`;
+						recordToolResult(toolsUsed, {
+							id: outcome.id,
+							name: outcome.name
+						}, errorMsg, false);
 						this.pushToolMessages(messages, {
 							id: outcome.id,
 							name: outcome.name,
 							parameters: outcome.parameters
-						}, `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`);
+						}, errorMsg);
 						continue;
 					}
 					const resultStr = outcome.result.toString();
@@ -23596,13 +24325,17 @@ var OpenAIBackend = class {
 						thisToolHadArtifact = true;
 						anyArtifactWasStreamed = true;
 						await callback(results, {
-							inputTokens: accumInputTokens + inputTokens,
+							...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 							outputTokens: accumOutputTokens + outputTokens,
 							toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
 							cacheStats
 						});
 					});
 					const sanitizedResult = thisToolHadArtifact ? resultStr.replace(/<artifact(?:\s[^>]*)?>[\s\S]*?<\/artifact>/gi, "[Artifact rendered and delivered to user]") : resultStr;
+					recordToolResult(toolsUsed, {
+						id: outcome.id,
+						name: outcome.name
+					}, sanitizedResult, true);
 					this.pushToolMessages(messages, {
 						id: outcome.id,
 						name: outcome.name,
@@ -23623,7 +24356,8 @@ var OpenAIBackend = class {
 							...options._internal,
 							toolCallCount: toolCallCount + 1,
 							accumInputTokens: accumInputTokens + inputTokens,
-							accumOutputTokens: accumOutputTokens + outputTokens
+							accumOutputTokens: accumOutputTokens + outputTokens,
+							accumCacheReadTokens: accumCacheReadTokens + cachedTokensFromStream
 						}
 					}, async (results, meta) => {
 						for (const r of results) if (r != null) recursiveBuffer += r;
@@ -23639,13 +24373,14 @@ var OpenAIBackend = class {
 						...options._internal,
 						toolCallCount: toolCallCount + 1,
 						accumInputTokens: accumInputTokens + inputTokens,
-						accumOutputTokens: accumOutputTokens + outputTokens
+						accumOutputTokens: accumOutputTokens + outputTokens,
+						accumCacheReadTokens: accumCacheReadTokens + cachedTokensFromStream
 					}
 				}, callback, toolsUsed);
 			} else {
 				this.logger.debug(`[Tool Execution] executeTools=false, passing tool calls to callback`);
 				await callback([null], {
-					inputTokens: accumInputTokens + inputTokens,
+					...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 					outputTokens: accumOutputTokens + outputTokens,
 					toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
 					cacheStats
@@ -23787,6 +24522,7 @@ var OpenAIBackend = class {
 		const toolCallCount = options._internal?.toolCallCount ?? 0;
 		const accumInputTokens = options._internal?.accumInputTokens ?? 0;
 		const accumOutputTokens = options._internal?.accumOutputTokens ?? 0;
+		const accumCacheReadTokens = options._internal?.accumCacheReadTokens ?? 0;
 		const chatMessages = this.formatMessages(messages, false, model, options);
 		const input = this.toResponsesInput(chatMessages);
 		const reasoningEffort = this.resolveReasoningEffort(model, options);
@@ -23813,8 +24549,9 @@ var OpenAIBackend = class {
 		let finalResponse;
 		let inputTokens = 0;
 		let outputTokens = 0;
+		let cachedTokensFromStream = 0;
 		for await (const event of stream) if (event.type === "response.output_text.delta") await callback([event.delta], {
-			inputTokens: accumInputTokens + inputTokens,
+			...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 			outputTokens: accumOutputTokens + outputTokens,
 			toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
 		});
@@ -23824,11 +24561,12 @@ var OpenAIBackend = class {
 		if (!finalResponse) throw new Error(`OpenAI Responses stream for ${model} ended without a terminal response event`);
 		inputTokens = finalResponse.usage?.input_tokens ?? 0;
 		outputTokens = finalResponse.usage?.output_tokens ?? 0;
+		cachedTokensFromStream = cachedTokensFromUsage(finalResponse.usage);
 		const functionCalls = finalResponse.output.filter((item) => item.type === "function_call");
 		if (functionCalls.length === 0) {
 			const stopReason = normalizeOpenAIResponsesStopReason(finalResponse.incomplete_details?.reason);
 			await callback([], {
-				inputTokens: accumInputTokens + inputTokens,
+				...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 				outputTokens: accumOutputTokens + outputTokens,
 				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
 				...stopReason ? { stopReason } : {}
@@ -23842,7 +24580,7 @@ var OpenAIBackend = class {
 		});
 		if (options.executeTools === false) {
 			await callback([null], {
-				inputTokens: accumInputTokens + inputTokens,
+				...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
 				outputTokens: accumOutputTokens + outputTokens,
 				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
 			});
@@ -23863,6 +24601,10 @@ var OpenAIBackend = class {
 				});
 			} catch {
 				this.logger.warn(`JSON parse error for ${fc.name} arguments (Responses path)`);
+				recordToolResult(toolsUsed, {
+					id: fc.call_id,
+					name: fc.name
+				}, "Error: Tool arguments were malformed and could not be parsed.", false);
 			}
 		}
 		const parallelEnabled = options.parallelToolExecution !== false;
@@ -23886,14 +24628,24 @@ var OpenAIBackend = class {
 		for (let i = 0; i < batchOutcomes.length; i++) {
 			const outcome = batchOutcomes[i];
 			const r = resolved[i];
-			if (outcome.ok) this.pushToolMessages(messages, {
-				id: r.callId,
-				name: r.name,
-				parameters: r.args
-			}, outcome.result.result.toString());
-			else {
+			if (outcome.ok) {
+				const resultStr = outcome.result.result.toString();
+				recordToolResult(toolsUsed, {
+					id: r.callId,
+					name: r.name
+				}, resultStr, true);
+				this.pushToolMessages(messages, {
+					id: r.callId,
+					name: r.name,
+					parameters: r.args
+				}, resultStr);
+			} else {
 				if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
 				const errorMsg = `Error processing ${r.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`;
+				recordToolResult(toolsUsed, {
+					id: r.callId,
+					name: r.name
+				}, errorMsg, false);
 				this.pushToolMessages(messages, {
 					id: r.callId,
 					name: r.name,
@@ -23910,7 +24662,8 @@ var OpenAIBackend = class {
 				...options._internal,
 				toolCallCount: toolCallCount + 1,
 				accumInputTokens: accumInputTokens + inputTokens,
-				accumOutputTokens: accumOutputTokens + outputTokens
+				accumOutputTokens: accumOutputTokens + outputTokens,
+				accumCacheReadTokens: accumCacheReadTokens + cachedTokensFromStream
 			}
 		}, callback, toolsUsed);
 	}
@@ -24268,6 +25021,10 @@ var XAIBackend = class {
 								this.logger.warn(`JSON parse error for ${toolCall.function.name} arguments`);
 								const entry = toolsUsed.find((t) => t.name === toolCall.function.name && t.id === toolCall.id);
 								if (entry) entry.arguments = "{}";
+								recordToolResult(toolsUsed, {
+									id: toolCall.id,
+									name: toolCall.function.name
+								}, "Error: Tool arguments were malformed and could not be parsed.", false);
 							}
 						}
 						const parallelEnabled = options.parallelToolExecution !== false;
@@ -24295,18 +25052,30 @@ var XAIBackend = class {
 							parameters: resolvedTools[i].parameters,
 							error: outcome.error
 						});
-						for (const outcome of outcomes) if (outcome.ok) this.pushToolMessages(messages, {
-							id: outcome.id,
-							name: outcome.name,
-							parameters: outcome.parameters
-						}, outcome.result.toString());
-						else {
+						for (const outcome of outcomes) if (outcome.ok) {
+							const resultStr = outcome.result.toString();
+							recordToolResult(toolsUsed, {
+								id: outcome.id,
+								name: outcome.name
+							}, resultStr, true);
+							this.pushToolMessages(messages, {
+								id: outcome.id,
+								name: outcome.name,
+								parameters: outcome.parameters
+							}, resultStr);
+						} else {
 							if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
+							const errorMessage = outcome.error instanceof Error ? outcome.error.message : "Unknown error";
+							const observation = `Error processing ${outcome.name} tool: ${errorMessage}`;
+							recordToolResult(toolsUsed, {
+								id: outcome.id,
+								name: outcome.name
+							}, observation, false);
 							this.pushToolMessages(messages, {
 								id: outcome.id,
 								name: outcome.name,
 								parameters: outcome.parameters
-							}, `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`);
+							}, observation);
 						}
 						await this.complete(model, messages, {
 							...options,
@@ -24436,6 +25205,10 @@ var XAIBackend = class {
 						this.logger.warn(`JSON parse error for ${name} arguments (streaming)`);
 						const entry = toolsUsed.find((t) => t.name === name && t.id === id);
 						if (entry) entry.arguments = "{}";
+						recordToolResult(toolsUsed, {
+							id,
+							name
+						}, "Error: Tool arguments were malformed and could not be parsed.", false);
 					}
 				}
 				const parallelEnabled = options.parallelToolExecution !== false;
@@ -24463,18 +25236,30 @@ var XAIBackend = class {
 					parameters: resolvedTools[i].parameters,
 					error: outcome.error
 				});
-				for (const outcome of outcomes) if (outcome.ok) this.pushToolMessages(messages, {
-					id: outcome.id,
-					name: outcome.name,
-					parameters: outcome.parameters
-				}, outcome.result.toString());
-				else {
+				for (const outcome of outcomes) if (outcome.ok) {
+					const resultStr = outcome.result.toString();
+					recordToolResult(toolsUsed, {
+						id: outcome.id,
+						name: outcome.name
+					}, resultStr, true);
+					this.pushToolMessages(messages, {
+						id: outcome.id,
+						name: outcome.name,
+						parameters: outcome.parameters
+					}, resultStr);
+				} else {
 					if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
+					const errorMessage = outcome.error instanceof Error ? outcome.error.message : "Unknown error";
+					const observation = `Error processing ${outcome.name} tool: ${errorMessage}`;
+					recordToolResult(toolsUsed, {
+						id: outcome.id,
+						name: outcome.name
+					}, observation, false);
 					this.pushToolMessages(messages, {
 						id: outcome.id,
 						name: outcome.name,
 						parameters: outcome.parameters
-					}, `Error processing ${outcome.name} tool: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`);
+					}, observation);
 				}
 				await this.complete(model, messages, {
 					...options,
@@ -25635,6 +26420,10 @@ function checkStaleModelReferences(input) {
 		for (const referencedId of chain) check("fallback-chain", chainKey, referencedId);
 	}
 	for (const referencedId of input.defaultChain ?? []) check("fallback-default", "default", referencedId);
+	for (const [agentName, decl] of Object.entries(input.agentModels ?? {})) {
+		if (decl.model) check("agent-model", agentName, decl.model);
+		for (const referencedId of decl.fallbackModels ?? []) check("agent-fallback", agentName, referencedId);
+	}
 	for (const [source, target] of Object.entries(DEPRECATED_MODEL_MAP)) check("deprecated-model-map", source, target);
 	for (const [source, target] of replacedByOverlayEntries()) check("replaced-by-overlay", source, target);
 	return found.sort((a, b) => a.surface.localeCompare(b.surface) || a.key.localeCompare(b.key) || a.referencedId.localeCompare(b.referencedId));
@@ -26099,13 +26888,19 @@ const toolUseSchema = z$1.object({
 * Discriminated union of streaming events. `thinking` blocks are opaque
 * provider-shaped objects (Anthropic extended thinking) replayed verbatim into
 * the next request, so they stay `unknown[]` rather than being modeled.
+*
+* `stopReason` must be declared to survive: this schema strips unknown keys, so a
+* field absent here is dropped at the boundary no matter what the server sends.
+* 'max_tokens' is the one value with user-visible consequences - it means the reply
+* was cut off rather than finished.
 */
 const streamEventSchema = z$1.discriminatedUnion("type", [
 	z$1.object({
 		type: z$1.literal("content"),
 		text: z$1.string().optional(),
 		usage: usageSchema.optional(),
-		credits: creditsSchema.optional()
+		credits: creditsSchema.optional(),
+		stopReason: z$1.string().optional()
 	}),
 	z$1.object({
 		type: z$1.literal("tool_use"),
@@ -26113,7 +26908,8 @@ const streamEventSchema = z$1.discriminatedUnion("type", [
 		tools: z$1.array(toolUseSchema).optional(),
 		thinking: z$1.array(z$1.unknown()).optional(),
 		usage: usageSchema.optional(),
-		credits: creditsSchema.optional()
+		credits: creditsSchema.optional(),
+		stopReason: z$1.string().optional()
 	}),
 	z$1.object({
 		type: z$1.literal("error"),
@@ -26182,12 +26978,14 @@ var StreamAccumulator = class {
 			case "content":
 				this.accumulatedText += event.text ?? "";
 				if (event.usage || event.credits) this.lastUsageInfo = extractUsageInfo(event);
+				if (event.stopReason) this.stopReason = event.stopReason;
 				break;
 			case "tool_use":
 				if (event.text) this.accumulatedText += event.text;
 				if (event.tools && event.tools.length > 0) this.toolsUsed = event.tools;
 				if (event.thinking && event.thinking.length > 0) this.thinkingBlocks = event.thinking;
 				if (event.usage || event.credits) this.lastUsageInfo = extractUsageInfo(event);
+				if (event.stopReason) this.stopReason = event.stopReason;
 		}
 	}
 	/** True when neither text nor tools have been accumulated (stream produced nothing useful). */
@@ -26214,10 +27012,14 @@ var StreamAccumulator = class {
 			const info = {
 				toolsUsed: this.toolsUsed,
 				thinking: this.thinkingBlocks.length > 0 ? this.thinkingBlocks : void 0,
-				...this.lastUsageInfo
+				...this.lastUsageInfo,
+				stopReason: this.stopReason
 			};
 			await callback([cleanedText], info);
-		} else if (cleanedText) await callback([cleanedText], this.lastUsageInfo);
+		} else if (cleanedText) await callback([cleanedText], {
+			...this.lastUsageInfo,
+			stopReason: this.stopReason
+		});
 	}
 };
 //#endregion
@@ -27328,7 +28130,7 @@ var AgentStore = class {
 	async loadAgentsFromDirectory(directory, source) {
 		try {
 			if (!(await fs$1.stat(directory)).isDirectory()) return;
-			const files = await this.findAgentFiles(directory);
+			const files = await findMarkdownFiles(directory);
 			for (const filePath of files) try {
 				const agent = await this.parseAgentFile(filePath, source);
 				this.agents.set(agent.name, agent);
@@ -27340,25 +28142,6 @@ var AgentStore = class {
 		}
 	}
 	/**
-	* Recursively find all .md files in directory
-	*/
-	async findAgentFiles(directory) {
-		const files = [];
-		try {
-			const entries = await fs$1.readdir(directory, { withFileTypes: true });
-			for (const entry of entries) {
-				const fullPath = path.join(directory, entry.name);
-				if (entry.isDirectory()) {
-					const subFiles = await this.findAgentFiles(fullPath);
-					files.push(...subFiles);
-				} else if (entry.isFile() && entry.name.endsWith(".md")) files.push(fullPath);
-			}
-		} catch (error) {
-			console.warn(`Error reading directory ${directory}:`, error instanceof Error ? error.message : String(error));
-		}
-		return files;
-	}
-	/**
 	* Parse a single agent markdown file
 	*/
 	async parseAgentFile(filePath, source) {
@@ -27675,7 +28458,8 @@ function buildFilenameMarkerRegex(markers) {
 * of the best-effort DB pre-filter. Fail-closed by design.
 */
 function isRetrievalExcluded(file, opts) {
-	if (opts.vectorizedOnly && !file.vectorized) return true;
+	const stalledByConvergence = isConvergencePausedNote(file.notes) || isChunkRebuildPending(file.chunkRebuildRequestedAt);
+	if (opts.vectorizedOnly && !file.vectorized && !stalledByConvergence) return true;
 	const re = buildFilenameMarkerRegex(opts.excludeFilenameMarkers);
 	return !!re && re.test((file.fileName ?? "").toLowerCase());
 }
@@ -28185,6 +28969,41 @@ function attachedContentExtractionBudget(maxSafeInputTokens, systemPromptReserve
 	const boundedReserve = Math.min(systemPromptReserve, Math.floor(maxSafeInputTokens * EXTRACTION_SYSTEM_RESERVE_MAX_SHARE));
 	return Math.max(0, Math.max(Math.floor(maxSafeInputTokens * MIN_ATTACHED_CONTENT_EXTRACTION_SHARE), Math.floor((maxSafeInputTokens - boundedReserve) * ATTACHED_CONTENT_EXTRACTION_SHARE)));
 }
+/**
+* Output budget used when a caller supplies no max_tokens. Within supported output limits for
+* every configured non-reasoning model; models that reason inside the output budget default to
+* ADAPTIVE_THINKING_MAX_TOKENS_FLOOR instead, since their reasoning would otherwise consume this
+* whole budget (see resolveOutputMaxTokens/reasonsWithinOutputBudget for which those are).
+* Distinct from the catalog's DEFAULT_MAX_OUTPUT_TOKENS, which fills in a model's *capability*
+* when its record omits one.
+*/
+const DEFAULT_OUTPUT_MAX_TOKENS = 4096;
+/**
+* Verbatim-history token budget shared by every caller that sizes one: how much of the model's
+* safe input window recent conversation turns may claim before older ones fall out to
+* contextSummary. Pulled into one place because ChatCompletionProcess.ts and
+* ChatCompletionFeatures.ts (QuestMaster) both need it and must not drift apart - the first
+* version of the QuestMaster call site hand-copied the formula and got the window wrong for
+* every model below the unknown-model floor.
+*
+* Always returns at least 1, even on a window so small or a message so long that the raw
+* subtraction goes to zero or negative: `Math.max(0, budget) && budget > 0` downstream treats a
+* falsy budget as "no budget given" and skips trimming entirely, which is the exact unbounded
+* history this function exists to prevent. A budget of 1 still trims to the single most recent
+* turn instead of disabling the trim.
+*/
+function computeVerbatimTokenBudget(modelInfo, requestedMaxTokens, opts) {
+	const modelMaxOutput = modelInfo.max_tokens ?? 16384;
+	const safeMaxTokens = resolveOutputMaxTokens({
+		requested: requestedMaxTokens,
+		fallback: DEFAULT_OUTPUT_MAX_TOKENS,
+		modelInfo,
+		modelMaxOutputTokens: modelMaxOutput
+	});
+	const safeInputTokens = Math.max(0, safeInputWindow(modelInfo, safeMaxTokens));
+	const availableForVerbatim = Math.max(0, safeInputTokens - opts.nonHistoryOverheadTokens);
+	return Math.max(1, Math.floor(availableForVerbatim * opts.verbatimWindowFraction));
+}
 /** The buffer buildAndSortMessages holds back before dividing the input window. */
 function assemblyTokenBuffer(maxInputTokens) {
 	return Math.max(MIN_TOKEN_BUFFER, Math.floor(maxInputTokens * TOKEN_BUFFER_PERCENTAGE));
@@ -29191,12 +30010,12 @@ const estimateMessagesTokens = (messages) => messages.reduce((sum, message) => s
 * staying synchronous (no N async tokenizer calls over a long history). Mirrors
 * the fields the conversion below actually emits into the prompt.
 */
-function estimateQuestTokenLength(item) {
+function estimateQuestTokenLength(item, disableToolReplay = false) {
 	const parts = [item.prompt ?? ""];
 	if (item.structuredReplies?.length) parts.push(JSON.stringify(item.structuredReplies));
 	else if (item.replies?.length) parts.push(item.replies.join("\n"));
 	if (item.toolResults?.length) parts.push(JSON.stringify(item.toolResults));
-	if (!item.structuredReplies?.length) {
+	if (!item.structuredReplies?.length && !disableToolReplay) {
 		const toolCalls = replayableToolCalls(item.promptMeta?.functionCalls);
 		if (toolCalls.length) parts.push(JSON.stringify(toolCalls));
 	}
@@ -29276,20 +30095,21 @@ async function generateSafeEmbedding(embeddingService, text, logger) {
 * history at all, and UNLIMITED_HISTORY_COUNT means no window (which still pages, since the
 * fetch needs some limit).
 */
-async function fetchAndProcessPreviousMessages(session, historyCount = null, { db, verbatimTokenBudget }) {
+async function fetchAndProcessPreviousMessages(session, historyCount = null, { db, verbatimTokenBudget, excludeCurrentPrompt = false, model }) {
 	if (!isUnlimitedHistory(historyCount) && historyCount !== null && historyCount <= 0) return [
 		[],
 		0,
 		{ cacheHit: false }
 	];
 	const limit = resolveHistoryFetchLimit(historyCount);
+	const disableToolReplay = !!model && isGeminiModelId(model);
 	const startTime = Date.now();
 	const chatHistoryItems = await db.quests.getMostRecentChatHistory(session.id, limit + 1);
 	const fetchTime = Date.now() - startTime;
 	const cacheIndicator = fetchTime < 50 ? "CACHE_HIT" : "CACHE_MISS";
 	Logger.globalInstance.log(`⚡ Message History ${cacheIndicator}: ${fetchTime}ms for session ${session.id.slice(-8)} (${chatHistoryItems.length} items)`);
 	chatHistoryItems.reverse();
-	if (chatHistoryItems.length > 1) chatHistoryItems.pop();
+	if (chatHistoryItems.length > 1 || excludeCurrentPrompt) chatHistoryItems.pop();
 	if (session.contextSummaryUpToQuestId) {
 		const boundary = session.contextSummaryUpToQuestId;
 		const filtered = chatHistoryItems.filter((item) => item.id > boundary);
@@ -29300,7 +30120,7 @@ async function fetchAndProcessPreviousMessages(session, historyCount = null, { d
 		let usedTokens = 0;
 		let keepFromIndex = 0;
 		for (let i = chatHistoryItems.length - 1; i >= 0; i--) {
-			usedTokens += estimateQuestTokenLength(chatHistoryItems[i]);
+			usedTokens += estimateQuestTokenLength(chatHistoryItems[i], disableToolReplay);
 			if (usedTokens > verbatimTokenBudget && i < chatHistoryItems.length - 1) {
 				keepFromIndex = i + 1;
 				break;
@@ -29332,7 +30152,7 @@ async function fetchAndProcessPreviousMessages(session, historyCount = null, { d
 					is_error: tr.is_error
 				}))
 			});
-		} else if (toolCalls.length > 0) {
+		} else if (toolCalls.length > 0 && !disableToolReplay) {
 			const textReply = cur.replies?.find((reply) => !reply.trim().startsWith("<think>")) || "";
 			const assistantContent = [];
 			if (textReply) assistantContent.push({
@@ -30517,6 +31337,7 @@ var llm_exports = /* @__PURE__ */ __exportAll({
 	ATTACHED_CONTENT_EXTRACTION_SHARE: () => ATTACHED_CONTENT_EXTRACTION_SHARE,
 	ATTACHMENT_DELIVERED_NOTICE: () => ATTACHMENT_DELIVERED_NOTICE,
 	BUILDER_INJECTED_BLOCK_IDS: () => BUILDER_INJECTED_BLOCK_IDS,
+	DEFAULT_OUTPUT_MAX_TOKENS: () => DEFAULT_OUTPUT_MAX_TOKENS,
 	EXTRACTION_SYSTEM_RESERVE_MAX_SHARE: () => EXTRACTION_SYSTEM_RESERVE_MAX_SHARE,
 	FORMAT_PROMPT_PRIORITY: () => 60,
 	IMAGE_PROMPT_PRIORITY: () => 50,
@@ -30532,6 +31353,7 @@ var llm_exports = /* @__PURE__ */ __exportAll({
 	buildAndSortMessages: () => buildAndSortMessages,
 	calculateTotalTokenLength: () => calculateTotalTokenLength,
 	computeCosineSimilarity: () => computeCosineSimilarity,
+	computeVerbatimTokenBudget: () => computeVerbatimTokenBudget,
 	effectiveContextWindow: () => effectiveContextWindow,
 	fetchAgentConversationHistory: () => fetchAgentConversationHistory,
 	fetchAndConvertFabFiles: () => fetchAndConvertFabFiles,
@@ -32437,7 +33259,12 @@ var BFLImageService = class extends AIImageService {
 					if (height) requestBody.height = height;
 				}
 				const cleanedBody = this.stripNullFields(requestBody);
-				Logger.globalInstance.debug("[DEBUG] BFL Image generation request body:", cleanedBody);
+				const safeRequestBody = {
+					...cleanedBody,
+					prompt: prompt.length > 100 ? `${prompt.slice(0, 100)}...` : prompt,
+					...cleanedBody.image_prompt ? { image_prompt: `[BASE64_DATA_${cleanedBody.image_prompt.length}_CHARS]` } : {}
+				};
+				Logger.globalInstance.log("BFL Image generation request body:", safeRequestBody);
 				const submitResponse = await axios.post(`${this.baseUrl}/${model}`, cleanedBody, { headers: {
 					accept: "application/json",
 					"x-key": this.apiKey,
@@ -32450,7 +33277,7 @@ var BFLImageService = class extends AIImageService {
 					pollingUrl,
 					responseData: submitResponse.data,
 					endpoint: `${this.baseUrl}/${model}`,
-					requestBody
+					requestBody: safeRequestBody
 				});
 				const imageUrl = await this.pollForResult(requestId, pollingUrl);
 				Logger.globalInstance.debug("[DEBUG] Received BFL image URL:", {
@@ -32859,8 +33686,6 @@ var GeminiImageService = class extends AIImageService {
 		const aspectRatio = this.resolveAspectRatio(options);
 		if (aspectRatio) config.aspectRatio = aspectRatio;
 		if (options.guidance !== null && options.guidance !== void 0) config.guidanceScale = options.guidance;
-		if (options.prompt_upsampling !== void 0) config.enhancePrompt = options.prompt_upsampling;
-		if (options.seed !== null && options.seed !== void 0) config.seed = options.seed;
 		const outputMimeType = this.resolveMimeType(options.output_format);
 		if (outputMimeType) config.outputMimeType = outputMimeType;
 		return config;
@@ -34171,11 +34996,11 @@ const DEFAULT_FALLBACK_CHAIN = [
 */
 function findAutomaticFallback(originalModel, availableModels, apiKeyTable, logger, excludeModelIds, preferUntriedBackend) {
 	logger.info(`🔍 Finding automatic fallback for ${originalModel.id}`);
-	const hasValidKey = (m) => !!apiKeyTable[m.backend] && apiKeyTable[m.backend] !== "expired";
+	const hasValidKey = (m) => !m.disabled && !!apiKeyTable[m.backend] && apiKeyTable[m.backend] !== "expired";
 	const preferences = [...FALLBACK_PREFERENCES[originalModel.id] ?? []];
 	if (preferences.length === 0) preferences.push(...DEFAULT_FALLBACK_CHAIN);
 	if (preferUntriedBackend) {
-		const triedBackends = /* @__PURE__ */ new Set([originalModel.backend]);
+		const triedBackends = new Set(originalModel.backend ? [originalModel.backend] : []);
 		for (const id of excludeModelIds ?? []) {
 			const tried = availableModels.find((m) => m.id === id);
 			if (tried) triedBackends.add(tried.backend);
@@ -34202,7 +35027,7 @@ function findAutomaticFallback(originalModel, availableModels, apiKeyTable, logg
 			return model;
 		}
 	}
-	logger.error("❌ No suitable automatic fallback model found");
+	logger.warn("⚠️ No suitable automatic fallback model found");
 	return null;
 }
 /**
@@ -34272,6 +35097,39 @@ async function getLlmWithFallback(originalModel, fallbackModelId, availableModel
 	return null;
 }
 /**
+* Pick a runnable substitute for a model id that is NOT in `availableModels` at all -
+* a sunset id a catalog lifecycle row has hidden, or one disabled since whatever
+* persisted it (a session pin, a stored mapping row) was written.
+*
+* `getLlmWithFallback` cannot serve this case: its `originalModel` is a `ModelInfo`,
+* which by definition does not exist here. This walks the same
+* `FALLBACK_PREFERENCES` -> `DEFAULT_FALLBACK_CHAIN` -> any-keyed-model selection
+* through the same `findAutomaticFallback`, so the substitute a hidden id lands on
+* cannot diverge from the one a listed-but-failing id would.
+*
+* Callers should run `resolveDeprecatedModelId` first: a sunset id with a known
+* successor should be forwarded to it (and counted as a `[model-sunset]`) rather
+* than treated as a model with no answer.
+*/
+function findFallbackForMissingModel(missingModelId, availableModels, apiKeyTable, logger, endUserId) {
+	const fallbackModel = findAutomaticFallback({ id: missingModelId }, availableModels, apiKeyTable, logger);
+	if (!fallbackModel) return null;
+	const backend = (0, llm_exports.getLlmByModel)(apiKeyTable, {
+		modelInfo: fallbackModel,
+		logger,
+		endUserId
+	});
+	if (!backend) {
+		logger.warn(`⚠️ Fallback for unavailable model ${missingModelId} failed to initialize: ${fallbackModel.id}`);
+		return null;
+	}
+	return {
+		model: fallbackModel,
+		backend,
+		attempt: 1
+	};
+}
+/**
 * Tiktoken-based implementation of the tokenizer interface
 * Provides caching for performance and configurable logging
 *
@@ -34792,6 +35650,7 @@ __reExport(/* @__PURE__ */ __exportAll({
 	ClientMessageSender: () => ClientMessageSender,
 	CorruptedFileError: () => CorruptedFileError,
 	DEFAULT_FALLBACK_CHAIN: () => DEFAULT_FALLBACK_CHAIN,
+	DEFAULT_OUTPUT_MAX_TOKENS: () => DEFAULT_OUTPUT_MAX_TOKENS,
 	DEFAULT_PASSAGE_TOKEN_TARGET: () => 512,
 	EXTRACTION_SYSTEM_RESERVE_MAX_SHARE: () => EXTRACTION_SYSTEM_RESERVE_MAX_SHARE,
 	ElevenLabsMusicGenerator: () => ElevenLabsMusicGenerator,
@@ -34879,6 +35738,7 @@ __reExport(/* @__PURE__ */ __exportAll({
 	checkStorageLimitForFile: () => checkStorageLimitForFile,
 	cleanMermaidSyntax: () => cleanMermaidSyntax,
 	computeCosineSimilarity: () => computeCosineSimilarity,
+	computeVerbatimTokenBudget: () => computeVerbatimTokenBudget,
 	convertCodeBlocksToArtifacts: () => convertCodeBlocksToArtifacts,
 	createQuestPlanToolSchema: () => createQuestPlanToolSchema,
 	createTokenizer: () => createTokenizer,
@@ -34894,6 +35754,7 @@ __reExport(/* @__PURE__ */ __exportAll({
 	fetchAndParseURL: () => fetchAndParseURL,
 	fetchAndProcessPreviousMessages: () => fetchAndProcessPreviousMessages,
 	filterRetrievalExcluded: () => filterRetrievalExcluded,
+	findFallbackForMissingModel: () => findFallbackForMissingModel,
 	formatVoiceHistory: () => formatVoiceHistory,
 	generateSafeEmbedding: () => generateSafeEmbedding,
 	getCachedSignedUrl: () => getCachedSignedUrl,