@bike4mind/cli 0.20.2 → 0.22.0

package/dist/{AgentHistoryStore-T7Oh84Yn.mjs → AgentHistoryStore-7zQUOxkA.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-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 { $ as SupportedFabFileMimeTypes, A as HTTPError, At as isPlaceholderApiKey, B as OPENAI_GPT_IMAGE_1_IMAGE_SIZES, Bt as reservationOutputTokens, Ct as isGPTImageModel, D as FIXED_TEMPERATURE_MODELS, Dt as isMediaModelType, E as FIELD_GROUP_OF, Et as isImageServeable, F as MODEL_INFO_FIELD_GROUP_OF, Ft as isUserInitiatedAbort, G as PermissionDeniedError, Gt as toModelRecord, H as OllamaEmbeddingModel, Ht as secureParameters, I as McpServerName, It as isZodError, J as REFUSAL_FALLBACK_MODELS, Jt as withRetry, K as REASONING_EFFORT_INCOMPATIBLE_WITH_TOOLS_MODELS, Kt as usdToCredits, L as ModelBackend, Lt as mapMimeTypeToArtifactType, M as IMAGE_SIZE_CONSTRAINTS, Mt as isRetryableError, N as ImageModels, Nt as isSupportedFabFileMimeType, O as FORMAT_PROMPT_TEMPLATE, Ot as isModelAccessible, P as InternalServerError, Pt as isUnlimitedHistory, Q as SpeechToTextModels, R as NO_TEMPERATURE_MODELS, Rt as obfuscateApiKey, S as CorruptedFileError, St as isGPTImage2Model, Tt as isImageAttachment, U as OpenAIEmbeddingModel, Ut as settingsMap, V as OPENAI_GPT_IMAGE_2_IMAGE_SIZES, Vt as resolveHistoryFetchLimit, Wt as toModelInfo, Y as RESPONSES_API_TOOL_MODELS, _ as BadRequestError, _t as isAudioMimeType, at as VideoModels, ct as applyModelPriceCatalog, dt as defaultEmbeddingModelForEnv, en as buildRateLimitLogEntry, et as TTS_MAX_INPUT_CHARS, ft as getMcpProviderMetadata, g as BFL_SAFETY_TOLERANCE, gt as hasUsableLimits, h as BEDROCK_NO_PROMPT_CACHING_MODELS, ht as hasKeylessCloudEmbedder, it as VIDEO_SIZE_CONSTRAINTS, j as HttpStatus, jt as isRenderableModelType, k as ForbiddenError, kt as isModelDeprecated, lt as calculateRetryDelay, m as ApiKeyType, mt as getRetryAfterMs, n as logger, nn as isNearLimit, nt as UnauthorizedError, ot as VoyageAIEmbeddingModel, p as ARTIFACT_ATTRS_PATTERN, pt as getQuestErrorCode, q as REASONING_SUPPORTED_MODELS, qt as usdToCreditsStochastic, rn as parseRateLimitHeaders, rt as UnprocessableEntityError, st as WORK_ITEM_STATUSES, tn as extractSnippetMeta, tt as TooManyRequestsError, ut as dayjsConfig_default, v as BedrockEmbeddingModel, vt as isChunkRebuildPending, w as DEFAULT_UNKNOWN_CONTEXT_WINDOW, wt as isGeminiModelId, x as ChatModels, xt as isFieldGroup, y as CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS, yt as isChunkStalledFile, z as NotFoundError, zt as parseEmbeddingRateLimitHeaders } from "./ConfigStore-8_0WsN5r.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";
@@ -21,6 +21,7 @@ import * as turndownPluginGfm from "@joplin/turndown-plugin-gfm";
 import * as cheerio from "cheerio";
 import FirecrawlDefault, { FirecrawlError } from "@mendable/firecrawl-js";
 import { lookup } from "node:dns/promises";
+import mongoose, { isObjectIdOrHexString } from "mongoose";
 import random from "lodash/random.js";
 import sum from "lodash/sum.js";
 import times from "lodash/times.js";
@@ -48,13 +49,12 @@ import { NodeHttpHandler } from "@smithy/node-http-handler";
 import "@opensearch-project/opensearch";
 import "@aws-sdk/credential-provider-node";
 import "@opensearch-project/opensearch/aws-v3";
-import mongoose from "mongoose";
 import { parse } from "shell-quote";
 import { homedir as homedir$1 } from "node:os";
 import { EventEmitter } from "events";
+import { CloudWatchClient, PutMetricDataCommand, StandardUnit } from "@aws-sdk/client-cloudwatch";
 import { fileURLToPath } from "url";
 import { Anthropic, RateLimitError } from "@anthropic-ai/sdk";
-import { CloudWatchClient, PutMetricDataCommand, StandardUnit } from "@aws-sdk/client-cloudwatch";
 import { GoogleGenAI } from "@google/genai";
 import pick from "lodash/pick.js";
 import { Stream } from "openai/streaming";
@@ -66,6 +66,7 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { getDomain } from "tldts";
 import * as dotenv from "dotenv";
+import { createHash as createHash$1 } from "node:crypto";
 import invert from "lodash/invert.js";
 import * as util from "node:util";
 import * as zlib from "node:zlib";
@@ -920,6 +921,7 @@ const DEMO_KEY_MAP = {
 	[ApiKeyType.gemini]: "geminiDemoKey",
 	[ApiKeyType.xai]: "xaiApiKey",
 	[ApiKeyType.kimi]: "moonshotApiKey",
+	[ApiKeyType.deepseek]: "deepseekApiKey",
 	[ApiKeyType.bfl]: "bflApiKey",
 	[ApiKeyType.voyageai]: "voyageApiKey",
 	[ApiKeyType.elevenlabs]: "elevenLabsServerApiKey"
@@ -977,6 +979,7 @@ const getEffectiveLLMApiKeys = async (userId, adapters, options) => {
 		ApiKeyType.bfl,
 		ApiKeyType.xai,
 		ApiKeyType.kimi,
+		ApiKeyType.deepseek,
 		ApiKeyType.voyageai
 	], adapters) : Promise.resolve([]), adapters.getSettingsByNames([
 		"openaiDemoKey",
@@ -985,6 +988,7 @@ const getEffectiveLLMApiKeys = async (userId, adapters, options) => {
 		"bflApiKey",
 		"xaiApiKey",
 		"moonshotApiKey",
+		"deepseekApiKey",
 		"voyageApiKey",
 		"ollamaBackend",
 		"EnableOllama"
@@ -997,6 +1001,7 @@ const getEffectiveLLMApiKeys = async (userId, adapters, options) => {
 	const bflUserKey = userKeyMap.get(ApiKeyType.bfl) || null;
 	const xaiUserKey = userKeyMap.get(ApiKeyType.xai) || null;
 	const kimiUserKey = userKeyMap.get(ApiKeyType.kimi) || null;
+	const deepseekUserKey = userKeyMap.get(ApiKeyType.deepseek) || null;
 	const voyageaiUserKey = userKeyMap.get(ApiKeyType.voyageai) || null;
 	const openaiDemoKey = adminSettings["openaiDemoKey"];
 	const anthropicDemoKey = adminSettings["anthropicDemoKey"];
@@ -1004,6 +1009,7 @@ const getEffectiveLLMApiKeys = async (userId, adapters, options) => {
 	const bflDemoKey = adminSettings["bflApiKey"];
 	const xaiDemoKey = adminSettings["xaiApiKey"];
 	const kimiDemoKey = adminSettings["moonshotApiKey"];
+	const deepseekDemoKey = adminSettings["deepseekApiKey"];
 	const voyageaiDemoKey = adminSettings["voyageApiKey"];
 	const ollamaBackend = adminSettings["ollamaBackend"];
 	const enableOllama = adminSettings["EnableOllama"];
@@ -1022,6 +1028,7 @@ const getEffectiveLLMApiKeys = async (userId, adapters, options) => {
 		bfl: keyOrExpired(bflUserKey) || bflDemoKey || null,
 		xai: keyOrExpired(xaiUserKey) || xaiDemoKey || envKey("XAI_API_KEY"),
 		kimi: keyOrExpired(kimiUserKey) || kimiDemoKey || envKey("MOONSHOT_API_KEY"),
+		deepseek: keyOrExpired(deepseekUserKey) || deepseekDemoKey || envKey("DEEPSEEK_API_KEY"),
 		voyageai: keyOrExpired(voyageaiUserKey) || voyageaiDemoKey || null,
 		ollama: (ollamaEnabled ? ollamaBackend || null : null) || envKey("OLLAMA_BASE_URL"),
 		imageGen: envKey("IMAGE_GEN_BASE_URL")
@@ -1836,7 +1843,27 @@ const webFetchTool = {
 	})
 };
 //#endregion
-//#region ../../b4m-core/services/dist/websearch-DpUKKZyj.mjs
+//#region ../../b4m-core/services/dist/websearch-BLmQCbHG.mjs
+/**
+* The coarse recency bucket both providers speak, as the smallest one containing `recencyDays`.
+* Null when there is no constraint, or when the window is wider than the widest bucket - a
+* "within 10 years" filter is not a filter, and sending one would exclude undated pages for nothing.
+*/
+function recencyBucket(recencyDays) {
+	if (typeof recencyDays !== "number" || !Number.isFinite(recencyDays) || recencyDays <= 0) return null;
+	if (recencyDays <= 1) return "day";
+	if (recencyDays <= 7) return "week";
+	if (recencyDays <= 31) return "month";
+	if (recencyDays <= 366) return "year";
+	return null;
+}
+/** SerpAPI spells the buckets `qdr:d|w|m|y` on the `tbs` parameter. */
+const SERPAPI_QDR = {
+	day: "qdr:d",
+	week: "qdr:w",
+	month: "qdr:m",
+	year: "qdr:y"
+};
 const DEFAULT_NUM_RESULTS = 3;
 const SEARCH_TIMEOUT_MS = 6e4;
 /**
@@ -1845,14 +1872,14 @@ const SEARCH_TIMEOUT_MS = 6e4;
 * on a non-OK response so the tool surfaces the failure. Exported (re-exported from index) for the
 * REST endpoint and existing tests.
 */
-async function serpApiSearch(adapters, query, num_results) {
+async function serpApiSearch(adapters, query, num_results, options) {
 	const apiKey = await (0, apiKeyService_exports.getSerperKey)(adapters);
 	const url = new URL("https://serpapi.com/search");
 	if (!apiKey) {
 		Logger.globalInstance.error("❌ WebSearch Tool: No API key configured. Skipping search.");
 		return { organic_results: [] };
 	}
-	url.search = new URLSearchParams({
+	const searchParams = new URLSearchParams({
 		engine: "google",
 		api_key: apiKey,
 		q: query,
@@ -1861,7 +1888,10 @@ async function serpApiSearch(adapters, query, num_results) {
 		gl: "us",
 		hl: "en",
 		num: (num_results || DEFAULT_NUM_RESULTS).toString()
-	}).toString();
+	});
+	const bucket = recencyBucket(options?.recencyDays);
+	if (bucket) searchParams.set("tbs", SERPAPI_QDR[bucket]);
+	url.search = searchParams.toString();
 	const controller = new AbortController();
 	const timeoutId = setTimeout(() => controller.abort(), SEARCH_TIMEOUT_MS);
 	let response;
@@ -1889,8 +1919,8 @@ async function serpApiSearch(adapters, query, num_results) {
 function createSerpApiProvider(adapters) {
 	return {
 		name: "serpapi",
-		async search(query, numResults) {
-			const data = await serpApiSearch(adapters, query, numResults);
+		async search(query, numResults, options) {
+			const data = await serpApiSearch(adapters, query, numResults, options);
 			return (Array.isArray(data.organic_results) ? data.organic_results : []).filter((r) => !!r && typeof r.link === "string").map((r) => ({
 				title: r.title ?? r.link,
 				url: r.link,
@@ -1929,16 +1959,19 @@ function parseSearxngResults(data, numResults) {
 function createSearxngProvider(baseUrl) {
 	return {
 		name: "searxng",
-		async search(query, numResults) {
+		async search(query, numResults, options) {
 			const limit = numResults && numResults > 0 ? numResults : DEFAULT_NUM_RESULTS;
 			const trimmed = baseUrl.replace(/\/+$/, "");
 			const url = new URL(`${trimmed}/search`);
-			url.search = new URLSearchParams({
+			const params = new URLSearchParams({
 				q: query,
 				format: "json",
 				language: "en",
 				safesearch: "1"
-			}).toString();
+			});
+			const bucket = recencyBucket(options?.recencyDays);
+			if (bucket) params.set("time_range", bucket);
+			url.search = params.toString();
 			const controller = new AbortController();
 			const timeoutId = setTimeout(() => controller.abort(), SEARCH_TIMEOUT_MS);
 			try {
@@ -2061,7 +2094,7 @@ const webSearchTool = {
 	})
 };
 //#endregion
-//#region ../../b4m-core/services/dist/toolGenerators-D3QFkvc-.mjs
+//#region ../../b4m-core/services/dist/toolGenerators-DGjRmthM.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();
@@ -2629,6 +2662,27 @@ const promptEnhancementTool = {
 		}
 	})
 };
+/**
+* Is this value shaped like something Mongoose can cast to an `_id`?
+*
+* Tool arguments are composed by the model out of conversation text and reach us as unvalidated
+* JSON, so an id parameter routinely holds something that is not an id at all - a filename token,
+* an arXiv number, a bare integer. Mongoose casts `_id` and throws a CastError on those, which a
+* generic catch upstream then reports as an outage rather than the bad argument it is (#2530).
+* Call this before handing a model-supplied id to `findById` and answer a false the same way the
+* surface answers a genuinely missing row.
+*
+* `isObjectIdOrHexString`, not `isValidObjectId`: the latter also accepts a number and casts it to
+* a fabricated id, and a model emitting `{"file_id": 12}` gives us exactly that despite the
+* `string` type. Same choice, same reason, as `usableObjectIds` in @bike4mind/db-core, which is
+* the array-shaped version of this check.
+*
+* NOT usable for artifact ids (`artifact_<...>`), which are matched on a string `id` field rather
+* than `_id` - see `createArtifactId` in @bike4mind/common.
+*/
+function isObjectIdShaped(id) {
+	return isObjectIdOrHexString(id);
+}
 let _showUserQuestion = null;
 /**
 * Inject the CLI callback that displays the question UI.
@@ -2748,7 +2802,7 @@ 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, suppressLakeArms, sessionRetrievalTags, questId, getAbortSignal }, 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, sessionPreauthorizedLakeIds, questId, getAbortSignal }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model, imageProcessorLambdaName, tools, allowedDirectories, entitlementKeys = [], sessionId, codeMinifier, availableModels, onToolLlmUsage) => {
 	const context = {
 		userId,
 		user,
@@ -2772,6 +2826,7 @@ const generateTools = (userId, user, logger, { db, retrievalFilter, kbScope, inl
 		fullyInlinedAttachmentIds,
 		suppressLakeArms,
 		sessionRetrievalTags,
+		sessionPreauthorizedLakeIds,
 		codeMinifier,
 		availableModels,
 		onToolLlmUsage,
@@ -4240,9 +4295,9 @@ const latticeAddEntityTool = {
 				createdAt: /* @__PURE__ */ new Date(),
 				updatedAt: /* @__PURE__ */ new Date()
 			};
-			if (context.db.latticeModels && modelId && /^[a-f0-9]{24}$/.test(modelId)) try {
+			if (context.db.latticeModels && modelId && isObjectIdShaped(modelId)) try {
 				const model = await context.db.latticeModels.findById(modelId);
-				if (model) {
+				if (model && model.userId === context.userId) {
 					const existingIndex = model.data.entities.findIndex((e) => e.id === entityId);
 					if (existingIndex >= 0) model.data.entities[existingIndex] = entityData;
 					else model.data.entities.push(entityData);
@@ -4252,7 +4307,23 @@ const latticeAddEntityTool = {
 						updatedAt: /* @__PURE__ */ new Date()
 					});
 					context.logger.info(`[Lattice] Added entity ${entityId} to model ${modelId}`);
-				} else context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+				} else if (model) {
+					context.logger.warn(`[Lattice] Access denied: caller does not own model ${modelId}`);
+					return JSON.stringify({
+						success: false,
+						action: "ADD_ENTITY",
+						modelId,
+						error: `Access denied: you do not have permission to modify model ${modelId}`
+					});
+				} else {
+					context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+					return JSON.stringify({
+						success: false,
+						action: "ADD_ENTITY",
+						modelId,
+						error: `Model ${modelId} not found`
+					});
+				}
 			} catch (error) {
 				context.logger.error(`[Lattice] Failed to persist entity to database:`, error);
 			}
@@ -4368,9 +4439,9 @@ const latticeSetValueTool = {
 			else if (rawValue.toLowerCase() === "true") value = true;
 			else if (rawValue.toLowerCase() === "false") value = false;
 			const entityId = entityName.toLowerCase().replace(/\s+/g, "_");
-			if (context.db.latticeModels && modelId && /^[a-f0-9]{24}$/.test(modelId)) try {
+			if (context.db.latticeModels && modelId && isObjectIdShaped(modelId)) try {
 				const model = await context.db.latticeModels.findById(modelId);
-				if (model) {
+				if (model && model.userId === context.userId) {
 					const entity = model.data.entities.find((e) => e.id === entityId || e.name === entityName);
 					if (entity) {
 						const attrIndex = entity.attributes.findIndex((a) => a.key === attributeKey);
@@ -4390,7 +4461,23 @@ const latticeSetValueTool = {
 						});
 						context.logger.info(`[Lattice] Set ${entityId}.${attributeKey} = ${value} in model ${modelId}`);
 					} else context.logger.warn(`[Lattice] Entity ${entityName} not found in model ${modelId}`);
-				} else context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+				} else if (model) {
+					context.logger.warn(`[Lattice] Access denied: caller does not own model ${modelId}`);
+					return JSON.stringify({
+						success: false,
+						action: "SET_VALUE",
+						modelId,
+						error: `Access denied: you do not have permission to modify model ${modelId}`
+					});
+				} else {
+					context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+					return JSON.stringify({
+						success: false,
+						action: "SET_VALUE",
+						modelId,
+						error: `Model ${modelId} not found`
+					});
+				}
 			} catch (error) {
 				context.logger.error(`[Lattice] Failed to persist value to database:`, error);
 			}
@@ -4487,9 +4574,9 @@ const latticeCreateRuleTool = {
 			};
 			const outputEntityId = parsedRule.outputEntity.toLowerCase().replace(/\s+/g, "_");
 			let entityCreatedMessage = "";
-			if (context.db.latticeModels && modelId && /^[a-f0-9]{24}$/.test(modelId)) try {
+			if (context.db.latticeModels && modelId && isObjectIdShaped(modelId)) try {
 				const model = await context.db.latticeModels.findById(modelId);
-				if (model) {
+				if (model && model.userId === context.userId) {
 					if (!model.data.entities.some((e) => e.id === outputEntityId || e.name.toLowerCase() === parsedRule.outputEntity.toLowerCase()) && parsedRule.outputEntity !== "unknown") {
 						const now = /* @__PURE__ */ new Date();
 						const newEntity = {
@@ -4526,7 +4613,23 @@ const latticeCreateRuleTool = {
 						updatedAt: /* @__PURE__ */ new Date()
 					});
 					context.logger.info(`[Lattice] Created rule ${ruleId} in model ${modelId}`);
-				} else context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+				} else if (model) {
+					context.logger.warn(`[Lattice] Access denied: caller does not own model ${modelId}`);
+					return JSON.stringify({
+						success: false,
+						action: "CREATE_RULE",
+						modelId,
+						error: `Access denied: you do not have permission to modify model ${modelId}`
+					});
+				} else {
+					context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+					return JSON.stringify({
+						success: false,
+						action: "CREATE_RULE",
+						modelId,
+						error: `Model ${modelId} not found`
+					});
+				}
 			} catch (error) {
 				context.logger.error(`[Lattice] Failed to persist rule to database:`, error);
 			}
@@ -6413,6 +6516,130 @@ var EmbeddingAuthError = class extends Error {
 		this.provider = provider;
 	}
 };
+/**
+* Passive reporting of embedding-provider rate-limit ceilings.
+*
+* A rate limit belongs to the provider organization behind the key, and every embedding response
+* already carries the ceiling in its headers, so reading them costs no extra request and no extra
+* tokens. Providers that do not report them (Bedrock, Ollama) simply never produce an observation.
+*
+* This module owns the "what did the provider say" half only. It has no opinion about data lakes
+* or about the throughput levers configured against these numbers; interpreting a ceiling against
+* a lever belongs to the layer that knows what the levers are.
+*/
+/**
+* Remaining/limit ratio at or below which the provider counts as under pressure. A bulk re-index
+* draws its window down steadily, so this sits low enough that ordinary throughput does not trip
+* it and only genuine starvation does.
+*/
+const PRESSURE_RATIO = .1;
+/**
+* Pressure lasts as long as the window does, and every call in that window reports it. Throttle to
+* one line per interval so a starved ingest leaves a readable trace instead of flooding the log.
+*/
+const PRESSURE_LOG_INTERVAL_MS = 6e4;
+/**
+* Process-local, and deliberately so: a cold start re-reports what it measures rather than leaving
+* a gap shared storage would have to close. Keyed by provider+model+account, so the map is bounded
+* by the model list times the number of distinct credentials the process serves.
+*/
+const stateByKey = /* @__PURE__ */ new Map();
+/**
+* A broken reporter is indistinguishable from a steady ceiling - both are silence - so the first
+* fault has to be loud. Subsequent ones drop to debug: whatever breaks here breaks on every
+* embedding call, and a bulk re-index would drown the log in it.
+*/
+let hasReportedFailure = false;
+const keyFor = (provider, model, account) => `${provider}:${model}:${account}`;
+const ceilingChanged = (previous, next) => previous.limitTokens !== next.limitTokens || previous.limitRequests !== next.limitRequests;
+const describeCeiling = (snapshot) => `${snapshot.limitTokens ?? "unreported"} tokens/min, ${snapshot.limitRequests ?? "unreported"} requests/min`;
+/** Ratio of the window still available, or null when the provider did not report that dimension. */
+const remainingRatio = (remaining, limit) => {
+	if (remaining === null || limit === null || limit <= 0) return null;
+	return remaining / limit;
+};
+const pressuredDimensions = (snapshot) => {
+	const tokens = remainingRatio(snapshot.remainingTokens, snapshot.limitTokens);
+	const requests = remainingRatio(snapshot.remainingRequests, snapshot.limitRequests);
+	const dimensions = [];
+	if (tokens !== null && tokens <= PRESSURE_RATIO) dimensions.push("tokens");
+	if (requests !== null && requests <= PRESSURE_RATIO) dimensions.push("requests");
+	return dimensions;
+};
+/**
+* Read the rate-limit headers off an embedding response and report the ceiling when it is worth
+* reporting: the first sighting in this process, a change since the last sighting, or the window
+* running down. Returns the observation when the provider reported a usable ceiling, else null.
+*
+* `account` identifies the provider account the reading belongs to and is part of the memo key,
+* not just the log line. The credential is resolved per user - a stored personal key beats the
+* platform key in `getEffectiveLLMApiKeys` - so one process can see several accounts on the same
+* provider+model. Without the discriminator their readings would collapse into one entry that
+* flaps between unrelated ceilings and attributes each figure to whoever reads the log next. The
+* caller supplies it; it must never be key material.
+*
+* Never throws. This hangs off the hot path of every embedding call, and a reporting fault must
+* not be able to fail an embedding that otherwise succeeded.
+*/
+function recordEmbeddingRateLimitHeaders(provider, model, account, headers, now = Date.now()) {
+	try {
+		const snapshot = parseEmbeddingRateLimitHeaders(headers);
+		if (!hasUsableLimits(snapshot)) return null;
+		const key = keyFor(provider, model, account);
+		const previous = stateByKey.get(key);
+		const observation = {
+			provider,
+			model,
+			account,
+			snapshot,
+			observedAt: now
+		};
+		const subject = `${provider} ${model} (account ${account})`;
+		if (!previous) Logger.globalInstance.info(`[embedding-limits] ${subject} ceiling measured: ${describeCeiling(snapshot)}`, {
+			provider,
+			model,
+			account,
+			limitTokens: snapshot.limitTokens,
+			limitRequests: snapshot.limitRequests
+		});
+		else if (ceilingChanged(previous.last.snapshot, snapshot)) Logger.globalInstance.warn(`[embedding-limits] ${subject} ceiling CHANGED: was ${describeCeiling(previous.last.snapshot)}, now ${describeCeiling(snapshot)}. Reconcile any throughput lever governed by this account against the new figure.`, {
+			provider,
+			model,
+			account,
+			previousLimitTokens: previous.last.snapshot.limitTokens,
+			previousLimitRequests: previous.last.snapshot.limitRequests,
+			limitTokens: snapshot.limitTokens,
+			limitRequests: snapshot.limitRequests
+		});
+		const pressured = pressuredDimensions(snapshot);
+		const dueForPressureLog = previous?.lastPressureLogAt == null || now - previous.lastPressureLogAt >= PRESSURE_LOG_INTERVAL_MS;
+		const logPressure = pressured.length > 0 && dueForPressureLog;
+		if (logPressure) Logger.globalInstance.warn(`[embedding-limits] ${subject} is at or below ${PRESSURE_RATIO * 100}% of its ${pressured.join(" and ")} window`, {
+			provider,
+			model,
+			account,
+			remainingTokens: snapshot.remainingTokens,
+			remainingRequests: snapshot.remainingRequests,
+			limitTokens: snapshot.limitTokens,
+			limitRequests: snapshot.limitRequests,
+			resetTokensMs: snapshot.resetTokensMs,
+			resetRequestsMs: snapshot.resetRequestsMs
+		});
+		stateByKey.set(key, {
+			last: observation,
+			lastPressureLogAt: logPressure ? now : previous?.lastPressureLogAt ?? null
+		});
+		return observation;
+	} catch (error) {
+		const message = `[embedding-limits] failed to record rate-limit headers: ${error}`;
+		if (hasReportedFailure) Logger.globalInstance.debug(message);
+		else {
+			hasReportedFailure = true;
+			Logger.globalInstance.warn(message);
+		}
+		return null;
+	}
+}
 const OPENAI_EMBEDDING_MODEL_MAP = {
 	[OpenAIEmbeddingModel.TEXT_EMBEDDING_3_SMALL]: {
 		provider: "OpenAI",
@@ -6433,34 +6660,72 @@ const OPENAI_EMBEDDING_MODEL_MAP = {
 		dimensions: [1536]
 	}
 };
-var OpenAIEmbeddingService = class OpenAIEmbeddingService {
+/**
+* Non-reversible stand-in for a credential, for use where two accounts have to be told apart in a
+* log. Same construction as the API-key logging hash in the request middleware. Never emit the key.
+*/
+const fingerprintCredential = (apiKey) => `key:${createHash("sha256").update(apiKey).digest("hex").slice(0, 16)}`;
+/**
+* Total by construction. The only caller runs inside processSingleBatch's classifying try, where a
+* throw would be misread as a provider error and re-issue the batch.
+*/
+const headerOrNull = (httpResponse, name) => {
+	try {
+		return httpResponse.headers?.get(name) ?? null;
+	} catch {
+		return null;
+	}
+};
+/**
+* The ceilings `generateEmbeddingBatch` splits on, at module scope and exported because a cost
+* PREFLIGHT has to model the same split before it spends (packages/scripts/retrieval/capturePlan.ts).
+* A second copy of these numbers in a script cannot track a provider change.
+*/
+const OPENAI_MAX_INPUTS_PER_REQUEST = 2048;
+const OPENAI_MAX_TOKENS_PER_INPUT = 8192;
+/**
+* Effective token limit with a 10% safety buffer.
+* The tiktoken fallback (text.length/3) deliberately overestimates to be safe,
+* but DB token counts may have been produced by a different tokenizer (Bedrock, Voyage)
+* that underestimates. The buffer keeps us clear of the hard limit under tokenizer variance.
+*/
+const OPENAI_EFFECTIVE_TOKEN_LIMIT = Math.floor(27e4);
+var OpenAIEmbeddingService = class {
 	client;
 	model;
-	/** Hard limit imposed by OpenAI's embeddings API. */
-	static MAX_TOKENS_PER_REQUEST = 3e5;
-	/**
-	* Effective token limit with a 10% safety buffer.
-	* The tiktoken fallback (text.length/3) deliberately overestimates to be safe,
-	* but DB token counts may have been produced by a different tokenizer (Bedrock, Voyage)
-	* that underestimates. The buffer keeps us clear of the hard limit under tokenizer variance.
-	*/
-	static EFFECTIVE_TOKEN_LIMIT = Math.floor(OpenAIEmbeddingService.MAX_TOKENS_PER_REQUEST * .9);
+	credentialFingerprint;
 	constructor(apiKey, model = OpenAIEmbeddingModel.TEXT_EMBEDDING_ADA_002) {
 		this.client = new OpenAI({ apiKey });
 		this.validateModel(model);
 		this.model = model;
+		this.credentialFingerprint = fingerprintCredential(apiKey);
+	}
+	/**
+	* Report the provider ceiling carried on a response we already received. Covers ingest and
+	* query alike: both reach OpenAI through this class, so neither needs its own sampling point.
+	*
+	* The ceiling belongs to the organization behind the key, and the key is resolved per user
+	* (getEffectiveLLMApiKeys prefers a stored personal key over the platform one), so the reading
+	* has to say whose it is. `openai-organization` is the provider's own answer to that; the
+	* credential fingerprint covers the case where the response omits it, and still keeps two
+	* distinct keys as two readings rather than one that flaps between them.
+	*/
+	recordRateLimit(httpResponse) {
+		const account = headerOrNull(httpResponse, "openai-organization") || this.credentialFingerprint;
+		recordEmbeddingRateLimitHeaders("OpenAI", this.model, account, httpResponse.headers);
 	}
 	validateModel(model) {
 		if (!OPENAI_EMBEDDING_MODEL_MAP[model]) throw new Error(`Invalid OpenAI embedding model: ${model}`);
 	}
 	async generateEmbedding(text) {
-		const response = await this.client.embeddings.create({
+		const { data: body, response: httpResponse } = await this.client.embeddings.create({
 			model: this.model,
 			input: text
-		}).catch((error) => {
+		}).withResponse().catch((error) => {
 			throw this.toActionableAuthError(error);
 		});
-		if (response.data && response.data.length > 0) return response.data[0].embedding;
+		this.recordRateLimit(httpResponse);
+		if (body.data && body.data.length > 0) return body.data[0].embedding;
 		throw new Error("No embedding data received from OpenAI");
 	}
 	/**
@@ -6491,8 +6756,6 @@ var OpenAIEmbeddingService = class OpenAIEmbeddingService {
 	*/
 	async generateEmbeddingBatch(texts, tokenCounts) {
 		if (texts.length === 0) return [];
-		const MAX_INPUTS_PER_REQUEST = 2048;
-		const MAX_TOKENS_PER_INPUT = 8192;
 		let tokens;
 		let needsRecalculation = false;
 		if (!tokenCounts || tokenCounts.length !== texts.length) needsRecalculation = true;
@@ -6507,12 +6770,12 @@ var OpenAIEmbeddingService = class OpenAIEmbeddingService {
 		let totalTokens = 0;
 		for (let i = 0; i < texts.length; i++) {
 			const tokenCount = tokens[i];
-			if (tokenCount > MAX_TOKENS_PER_INPUT) throw new Error(`Input at index ${i} exceeds ${MAX_TOKENS_PER_INPUT} token limit (${tokenCount} tokens)`);
+			if (tokenCount > 8192) throw new Error(`Input at index ${i} exceeds ${OPENAI_MAX_TOKENS_PER_INPUT} token limit (${tokenCount} tokens)`);
 			totalTokens += tokenCount;
 		}
 		Logger.globalInstance.debug(`[OpenAI] Batch embedding: ${texts.length} inputs, ${totalTokens} total tokens`);
-		const batches = this.createBatches(texts, tokens, MAX_INPUTS_PER_REQUEST, OpenAIEmbeddingService.EFFECTIVE_TOKEN_LIMIT);
-		Logger.globalInstance.debug(`[OpenAI] Split into ${batches.length} batch(es) (effective limit: ${OpenAIEmbeddingService.EFFECTIVE_TOKEN_LIMIT} tokens)`);
+		const batches = this.createBatches(texts, tokens, OPENAI_MAX_INPUTS_PER_REQUEST, OPENAI_EFFECTIVE_TOKEN_LIMIT);
+		Logger.globalInstance.debug(`[OpenAI] Split into ${batches.length} batch(es) (effective limit: ${OPENAI_EFFECTIVE_TOKEN_LIMIT} tokens)`);
 		if (batches.length === 1) return await this.processSingleBatch(batches[0].texts);
 		const allEmbeddings = new Array(texts.length);
 		for (const batch of batches) (await this.processSingleBatch(batch.texts)).forEach((embedding, batchIndex) => {
@@ -6578,8 +6841,8 @@ var OpenAIEmbeddingService = class OpenAIEmbeddingService {
 	async processSingleBatch(texts, preCalculatedTokens) {
 		const tokenCounts = preCalculatedTokens || await this.calculateTokenCounts(texts);
 		const batchTokens = tokenCounts.reduce((sum, count) => sum + count, 0);
-		if (batchTokens > OpenAIEmbeddingService.EFFECTIVE_TOKEN_LIMIT) {
-			Logger.globalInstance.warn(`[OpenAI] Batch exceeds effective token limit (${batchTokens}/${OpenAIEmbeddingService.EFFECTIVE_TOKEN_LIMIT} tokens), splitting recursively`);
+		if (batchTokens > 27e4) {
+			Logger.globalInstance.warn(`[OpenAI] Batch exceeds effective token limit (${batchTokens}/${OPENAI_EFFECTIVE_TOKEN_LIMIT} tokens), splitting recursively`);
 			const mid = Math.ceil(texts.length / 2);
 			const firstHalf = texts.slice(0, mid);
 			const secondHalf = texts.slice(mid);
@@ -6588,13 +6851,14 @@ var OpenAIEmbeddingService = class OpenAIEmbeddingService {
 			const [firstEmbeddings, secondEmbeddings] = await Promise.all([this.processSingleBatch(firstHalf, firstTokens), this.processSingleBatch(secondHalf, secondTokens)]);
 			return [...firstEmbeddings, ...secondEmbeddings];
 		}
-		for (let i = 0; i < tokenCounts.length; i++) if (tokenCounts[i] > 8192) throw new Error(`Text at index ${i} exceeds OpenAI's 8192 token limit per input (${tokenCounts[i]} tokens). This indicates a data integrity issue - chunk should have been smaller. This chunk cannot be processed and the entire batch must fail.`);
+		for (let i = 0; i < tokenCounts.length; i++) if (tokenCounts[i] > 8192) throw new Error(`Text at index ${i} exceeds OpenAI's ${OPENAI_MAX_TOKENS_PER_INPUT} token limit per input (${tokenCounts[i]} tokens). This indicates a data integrity issue - chunk should have been smaller. This chunk cannot be processed and the entire batch must fail.`);
 		try {
-			const response = await this.client.embeddings.create({
+			const { data: body, response: httpResponse } = await this.client.embeddings.create({
 				model: this.model,
 				input: texts
-			});
-			if (response.data && response.data.length > 0) return response.data.sort((a, b) => a.index - b.index).map((item) => item.embedding);
+			}).withResponse();
+			this.recordRateLimit(httpResponse);
+			if (body.data && body.data.length > 0) return body.data.sort((a, b) => a.index - b.index).map((item) => item.embedding);
 			else throw new Error("No embedding data received from OpenAI");
 		} catch (error) {
 			if (error instanceof OpenAI.AuthenticationError) throw this.toActionableAuthError(error);
@@ -6993,7 +7257,25 @@ const getProviderFromModel = (modelName) => {
 * ("OpenAI rejected the embedding request") instead of the actionable missing-credential path.
 */
 const EXPIRED_KEY_SENTINEL = "expired";
-const usableKey = (value) => value && value !== EXPIRED_KEY_SENTINEL ? value : null;
+/**
+* A placeholder is rejected for the same reason the sentinel is, and the two sibling answers to
+* "is this key usable" both already do it (modelDiscoveryService/credentials.ts,
+* toolAvailability.ts, and defaultEmbeddingModelForEnv's own key test). Keeping a placeholder here
+* would report `missing: null`, so the keyless fallback would never fire and EmbeddingFactory would
+* then throw on the placeholder itself - the PR's headline case failing silently rather than
+* substituting. `.trim()` because a whitespace-only value is no key either.
+*/
+const usableKey = (value) => {
+	const trimmed = value?.trim();
+	if (!trimmed || trimmed === EXPIRED_KEY_SENTINEL || isPlaceholderApiKey(trimmed)) return null;
+	return trimmed;
+};
+/**
+* The slot is missing because THIS CALLER's key expired, not because the deployment holds none.
+* Bedrock has no credential and Ollama's base URL carries no expiry, so only the two keyed cloud
+* providers can be in this state. See the keyless-fallback doc comment for why it matters.
+*/
+const isExpiredCallerKey = (missing, keyTable) => missing === "openai" && keyTable?.openai === EXPIRED_KEY_SENTINEL || missing === "voyageai" && keyTable?.voyageai === EXPIRED_KEY_SENTINEL;
 /**
 * Map an embedding provider plus the caller's resolved key table to the config
 * `EmbeddingFactory` expects, and report which credential is missing if any.
@@ -7013,6 +7295,13 @@ const usableKey = (value) => value && value !== EXPIRED_KEY_SENTINEL ? value : n
 *
 * Adding a provider means editing this function and its table test, not auditing
 * every call site.
+*
+* `keyTable` is always an ANSWER about the caller's credentials, never a failure channel. `null` /
+* `undefined` mean "resolved: this caller holds none", and both this function and the keyless
+* fallback below act on that - substituting the keyless embedder is a real decision with a real
+* vector space attached. A caller whose own key lookup THREW must therefore not pass the failure in
+* here; it has to report unknown instead, or an unavailable Mongo becomes a confident Titan on a
+* fully keyed production stage.
 */
 function resolveEmbeddingConfig(provider, keyTable) {
 	switch (provider) {
@@ -7036,19 +7325,78 @@ function resolveEmbeddingConfig(provider, keyTable) {
 				missing: "voyageai"
 			};
 		}
-		case ModelBackend.Ollama: return keyTable?.ollama ? {
-			config: { ollamaBaseUrl: keyTable.ollama },
-			missing: null
-		} : {
-			config: {},
-			missing: "ollama"
-		};
+		case ModelBackend.Ollama: {
+			const baseUrl = keyTable?.ollama?.trim();
+			return baseUrl ? {
+				config: { ollamaBaseUrl: baseUrl },
+				missing: null
+			} : {
+				config: {},
+				missing: "ollama"
+			};
+		}
 		case ModelBackend.Bedrock: return {
 			config: {},
 			missing: null
 		};
 	}
 }
+/**
+* Resolve a config for `model`, falling back to keyless Bedrock when this deployment holds no
+* credential for the provider `model` needs but can reach Bedrock with its own AWS role.
+*
+* WHY THIS EXISTS HERE and not in `defaultEmbeddingModelForEnv`: "does this deployment have a
+* cloud embedding key" is unanswerable from process.env on a hosted stage - an SST secret arrives
+* as a linked Resource, so OPENAI_API_KEY is absent on production exactly as it is on a preview.
+* The key table passed in here is the first point that actually knows, which is why the decision
+* belongs at this seam.
+*
+* Related to but NOT the same as EmbeddingFactory.getDefaultEmbeddingModel, which ranks providers
+* from scratch (OpenAI > VoyageAI > Ollama > Bedrock). This keeps the model the admin asked for
+* whenever it is reachable and only substitutes the keyless one otherwise - so a deployment
+* holding only a Voyage key still falls back to Bedrock here, where the factory would pick
+* voyage-3. Deliberate: this is a reachability backstop, not a second opinion on the setting.
+*
+* ONLY FOR CALLERS FREE TO CHOOSE THE MODEL - i.e. the model came from the `defaultEmbeddingModel`
+* admin setting. A caller that must hit one specific vector space MUST keep using
+* `resolveEmbeddingConfig` and fail, because a fallback there would silently compare or write
+* across incompatible spaces:
+*   - V2 mementos are pinned to MEMENTO_EMBEDDING_MODEL at 512 truncated dims (see embedding.ts);
+*   - V1 mementos (mementoEmbedding.ts, getRelevantMementos.ts) read the admin default and so LOOK
+*     free to choose, but neither live write path stamps `Memento.embeddingModel` - only the
+*     reembedMementos backfill does. Their vectors are ranked by in-process cosine with no width
+*     guard and no Atlas index, so a substitution here would drop 1024-dim vectors into a field
+*     holding 1536-dim ones with nothing recording which is which, and nothing able to tell them
+*     apart afterwards. Stamping V1 is the prerequisite for including it, not this helper.
+*   - alternateModelAnn embeds one query per model bucket to match each chunk's recorded stamp.
+*
+* Returns the model actually used, so callers stamp what they embedded with rather than what they
+* asked for - that is what keeps `fabFileChunk`'s recorded `embeddingModel` honest.
+*
+* TWO credential states are deliberately NOT treated as "this deployment is keyless":
+*   - `missing: 'ollama'` - a self-host that set no OLLAMA_BASE_URL has no AWS role either, and
+*     OPENAI_KEY_MISSING_MESSAGE naming OPENAI_API_KEY / OLLAMA_BASE_URL is the actionable error
+*     there. `hasKeylessCloudEmbedder()` already excludes self-host; this is belt-and-braces.
+*   - an EXPIRED caller key. `getEffectiveLLMApiKeys` returns the `'expired'` sentinel instead of
+*     falling through to the platform demo key, deliberately, so the user is told their key
+*     expired rather than silently moved onto the platform's (see the reasoning in the
+*     reactivate-collateral-deactivated-api-keys migration). `usableKey` normalizes that to null
+*     for the CREDENTIAL check, which is right - but read as "this deployment holds no key" it
+*     would substitute Titan for that one caller on keyed production, querying a vector space the
+*     corpus was never written in. The deployment's own key state is unchanged by one expiry, so
+*     the requested model is returned and the actionable expired-key error stands.
+*/
+function resolveEmbeddingWithKeylessFallback(model, keyTable) {
+	const resolved = resolveEmbeddingConfig(getProviderFromModel(model), keyTable);
+	if (!resolved.missing || resolved.missing === "ollama" || isExpiredCallerKey(resolved.missing, keyTable) || !hasKeylessCloudEmbedder()) return {
+		...resolved,
+		model
+	};
+	return {
+		...resolveEmbeddingConfig(ModelBackend.Bedrock, null),
+		model: BedrockEmbeddingModel.TITAN_TEXT_EMBEDDINGS_V2
+	};
+}
 const ChunkSchema = z$1.object({
 	text: z$1.string(),
 	tokenCount: z$1.number()
@@ -8116,6 +8464,50 @@ async function fetchWithoutRedirects(url, timeoutMs) {
 		validateStatus: (status) => status >= 200 && status < 300 || status >= 300 && status < 400
 	});
 }
+const BLOCK_LEVEL_SELECTOR = `*:not(${"a, span, em, strong, b, i, u, code, kbd, samp, var, sub, sup, small, abbr, cite, q, time, mark, s, del, ins, bdi, bdo, wbr, ruby, rt, rp".split(", ").join("):not(")}):not(td):not(th)`;
+/**
+* Extract readable text from the WHOLE document, not just `<p>` elements. The single collector
+* this replaced was `<p>`-only and fell back to the raw HTML when it found none: on a page whose
+* content isn't inside `<p>` (an RFC page using `<pre>`) that meant the fallback fired and stored
+* markup verbatim; on a page with real substance in headings, list items, table cells or code
+* blocks alongside its `<p>`s, that content was silently dropped.
+*
+* `head` (title/meta/script/style all live there, and the caller already reads `<title>`
+* separately) plus any stray `script`/`style`/`noscript` outside it are removed before extraction,
+* so none of that reaches what gets embedded. `<pre>` content is pulled out and stashed BEFORE the
+* rest of the document is collapsed, and spliced back in verbatim afterward - it needs to skip the
+* whitespace-collapse below (a code block's leading-space indentation is meaningful, unlike prose
+* whitespace) but still needs to land in the right place relative to everything else. Table cells
+* get a trailing space (still the same row, but no longer jammed into the next cell's word); every
+* other block-level element gets a trailing newline; runs of whitespace and blank lines are then
+* collapsed. Returns `''` when nothing extractable was found, so the caller stores nothing rather
+* than falling back to raw HTML.
+*/
+function extractReadableText($) {
+	$("head, script, style, noscript").remove();
+	$("br").replaceWith("\n");
+	const nonce = Math.random().toString(36).slice(2) + Date.now().toString(36);
+	const markerFor = (index) => `\uE000PRE${nonce}_${index}\uE000`;
+	const markerPattern = new RegExp(`\\uE000PRE${nonce}_(\\d+)\\uE000`, "g");
+	const preBlocks = [];
+	$("pre").each((_index, element) => {
+		const text = $(element).text();
+		if (text) {
+			preBlocks.push(text);
+			$(element).replaceWith(`${markerFor(preBlocks.length - 1)}\n`);
+		} else $(element).remove();
+	});
+	$("td, th").each((_index, cell) => {
+		$(cell).after(" ");
+	});
+	$(BLOCK_LEVEL_SELECTOR).each((_index, element) => {
+		$(element).after("\n");
+	});
+	return $.root().text().split("\n").map((line) => line.replace(/[ \t]+/g, " ").trim()).filter(Boolean).join("\n").replace(markerPattern, (match, indexStr) => {
+		const index = Number(indexStr);
+		return index >= 0 && index < preBlocks.length ? preBlocks[index] : match;
+	});
+}
 async function fetchAndParseURL(url, { logger }) {
 	logger.updateMetadata({ failedUrl: null });
 	try {
@@ -8149,16 +8541,13 @@ async function fetchAndParseURL(url, { logger }) {
 			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;
+			urlContent = extractReadableText($);
 		}
 		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}`);
+		if (urlContent === "") logger.log(`Fetched ${title} with mimetype ${urlMimeType} and parsed ${fetched}, but no extractable text was found`);
+		else logger.log(`Fetched ${title} with mimetype ${urlMimeType} and parsed ${fetched}`);
 		return {
 			title,
 			textContent: urlContent,
@@ -9821,16 +10210,16 @@ function parseSettingsHooks(settingsJson) {
 		return null;
 	}
 }
-let cached;
+let cached$1;
 /**
 * Lazily-built process-hook singleton from `B4M_SETTINGS_JSON`. Returns null when
 * no hooks are configured, so call sites can `void getProcessHooks()?.fireStop()`.
 */
 function getProcessHooks() {
-	if (cached !== void 0) return cached;
+	if (cached$1 !== void 0) return cached$1;
 	const hooks = parseSettingsHooks(process.env.B4M_SETTINGS_JSON);
-	cached = hooks ? new ProcessHooks(hooks) : null;
-	return cached;
+	cached$1 = hooks ? new ProcessHooks(hooks) : null;
+	return cached$1;
 }
 //#endregion
 //#region src/agents/interactionModeClamp.ts
@@ -12901,10 +13290,117 @@ const vm = require('node:vm');
 const STDOUT_HEAD_BYTES = ${5e3};
 const STDOUT_TAIL_BYTES = ${2e3};
 const HARD_PER_LINE_BYTES = ${5e4};
+const MIRROR_TAIL_FLUSH_MS = ${100};
 
 let stdoutChunks = [];
-let stdoutBytes = 0;
 let truncated = false;
+// --- Mirror state --------------------------------------------------------
+// Mirrors this run's stdout to the main thread as it is produced, in the same
+// head + marker + tail shape collectStdout() produces, so a retired run and a
+// completed one report the same thing by the same rule.
+//
+// The two halves are cost-bounded differently. The head is mirrored line by
+// line, so a chatty loop stops paying per line once the head is full. Past
+// that the tail is kept locally in a rolling window and posted on a timer, so
+// the message rate stops tracking the line rate entirely.
+let currentRunId = null;
+let mirroredHeadBytes = 0;
+let headMirrorFull = false;
+let tailChunks = [];
+let tailBytes = 0;
+let elidedBytes = 0;
+let tailFlushTimer = null;
+
+/**
+ * What the rolling tail may hold: whatever the head did not use of the same
+ * HEAD + TAIL total collectStdout() reports within. A fixed TAIL budget made
+ * the two disagree whenever the head came up short - a single 6KB first line
+ * does not fit the head, so the mirror would have kept 2KB of a run that
+ * collectStdout() reports whole, and called it truncated. mirroredHeadBytes
+ * is frozen once the head is full, so this is stable for the rest of the run.
+ */
+function tailBudget() {
+  return STDOUT_HEAD_BYTES + STDOUT_TAIL_BYTES - mirroredHeadBytes;
+}
+
+function postToMain(msg) {
+  try { parentPort.postMessage(msg); } catch { /* worker being torn down; nothing to preserve */ }
+}
+function cancelTailFlush() {
+  if (tailFlushTimer === null) return;
+  clearTimeout(tailFlushTimer);
+  tailFlushTimer = null;
+}
+function flushTail() {
+  if (currentRunId === null || !headMirrorFull) return;
+  const joined = tailChunks.join('\n');
+  // The rolling window is trimmed line by line, so it can only exceed the
+  // budget by holding ONE line longer than the whole budget. Slice to the
+  // same last-N-chars rule collectStdout() uses, which both matches that
+  // path and keeps the flush payload bounded - a guest printing 50KB lines
+  // would otherwise re-send 50KB on every tick.
+  const overflow = Math.max(0, joined.length - tailBudget());
+  postToMain({
+    type: 'stdoutTail',
+    id: currentRunId,
+    tail: overflow > 0 ? joined.slice(overflow) : joined,
+    // Counted from what was actually DROPPED - lines the rolling window
+    // evicted, plus whatever this payload's own slice cuts - rather than
+    // derived from the byte totals. The derived form read zero on the first
+    // flush by construction (every line was still in the head, so the
+    // subtraction cancelled), which made "truncated" unreportable on exactly
+    // the run the mirror exists for.
+    elidedBytes: elidedBytes + overflow,
+  });
+}
+function scheduleTailFlush() {
+  if (tailFlushTimer !== null) return;
+  tailFlushTimer = setTimeout(() => {
+    tailFlushTimer = null;
+    flushTail();
+  }, MIRROR_TAIL_FLUSH_MS);
+}
+function mirrorLine(capped) {
+  if (currentRunId === null) return;
+  if (!headMirrorFull) {
+    // Does THIS line fit, rather than "is the running total already over".
+    // Both of the orderings tried before this were wrong in one direction
+    // each: gating on the running total let one line of up to
+    // HARD_PER_LINE_BYTES past a 5KB budget (mirrored head ~55KB, disagreeing
+    // with collectStdout's head and with the "~7K chars" codeExecuteTool
+    // advertises to the model), while adding first and checking after moved
+    // the boundary but kept the crossing line in the head - so the tail was
+    // still empty at the immediate flush below and a run killed right there
+    // dropped the last line before the hang and reported itself complete.
+    //
+    // A fit check does both: the head stops at STDOUT_HEAD_BYTES exactly, and
+    // the line that did not fit STARTS the tail, so the flush that fires on
+    // this same call carries it.
+    if (mirroredHeadBytes + capped.length + 1 <= STDOUT_HEAD_BYTES) {
+      mirroredHeadBytes += capped.length + 1;
+      postToMain({ type: 'stdout', id: currentRunId, chunk: capped });
+      return;
+    }
+    headMirrorFull = true;
+    tailChunks.push(capped);
+    tailBytes += capped.length + 1;
+    // Post once immediately: a run killed before the first timed flush would
+    // otherwise report a short mirror as if it were complete.
+    flushTail();
+    return;
+  }
+  tailChunks.push(capped);
+  tailBytes += capped.length + 1;
+  // Never evict the only line held: a line larger than the whole budget is
+  // still the last thing the run printed, which is what the mirror is for.
+  const budget = tailBudget();
+  while (tailBytes > budget && tailChunks.length > 1) {
+    const dropped = tailChunks.shift();
+    tailBytes -= dropped.length + 1;
+    elidedBytes += dropped.length + 1;
+  }
+  scheduleTailFlush();
+}
 function captureLine(args) {
   const line = args.map(a => {
     if (typeof a === 'string') return a;
@@ -12916,7 +13412,7 @@ function captureLine(args) {
     ? line.slice(0, HARD_PER_LINE_BYTES) + ' [...line truncated]'
     : line;
   stdoutChunks.push(capped);
-  stdoutBytes += capped.length + 1;
+  mirrorLine(capped);
 }
 function jsonReplacer(_k, v) {
   if (v instanceof Error) return { name: v.name, message: v.message };
@@ -13017,7 +13513,11 @@ parentPort.on('message', async (msg) => {
   }
   if (msg.type === 'runCode') {
     const t0 = Date.now();
-    stdoutChunks = []; stdoutBytes = 0; truncated = false;
+    stdoutChunks = []; truncated = false;
+    cancelTailFlush();
+    currentRunId = msg.id;
+    mirroredHeadBytes = 0; headMirrorFull = false;
+    tailChunks = []; tailBytes = 0; elidedBytes = 0;
     let error = null;
     const wrapped = '(async () => {\n' + msg.code + '\n})()';
     try {
@@ -13029,6 +13529,11 @@ parentPort.on('message', async (msg) => {
     } catch (e) {
       error = serializeError(e);
     }
+    // Stop mirroring before the authoritative result goes out, so a late
+    // console.log from an abandoned continuation cannot attach to this run,
+    // and a pending tail flush cannot land after it.
+    currentRunId = null;
+    cancelTailFlush();
     parentPort.postMessage({
       type: 'runResult',
       id: msg.id,
@@ -13042,6 +13547,17 @@ parentPort.on('message', async (msg) => {
 });
 `;
 String.raw`
+// Wrapped in an IIFE deliberately. A script's top-level const/let bind into the
+// context's SHARED global lexical scope (and its function declarations become
+// globalThis properties), so without this wrapper every bootstrap-local name is
+// directly referenceable by LLM-authored code run later in the same context:
+// __RealFunction('...')() walks straight around the codegen block below, and
+// __cap.applySync(...) / __cap.release() forges or permanently kills stdout
+// capture. Function scope keeps them unreachable. Note the leak is invisible to
+// listGlobals(), which reads Object.getOwnPropertyNames(globalThis) and never
+// saw the lexical bindings - so RESERVED_GLOBAL_NAMES cannot backstop it either.
+// Anything guest code IS meant to see is assigned onto globalThis explicitly.
+(function () {
 const __cap = _captureLine;
 const __callTool = _callTool;
 delete globalThis._captureLine;
@@ -13049,28 +13565,68 @@ delete globalThis._callTool;
 
 const HARD_PER_LINE_BYTES = ${5e4};
 
+// Every intrinsic the formatter below reaches for is captured HERE, while the
+// context is still pristine. Resolving \`args.map\` / \`.join\` / \`line.slice\`
+// at CALL time walks a prototype chain the guest owns, so one
+// \`Array.prototype.join = () => 'X'\` - deliberate, or an innocent polyfill -
+// forges every stdout line for the rest of the session, and the run still
+// reports error=null / truncated=false. That is the same integrity failure the
+// frozen \`console\` below exists to prevent, one level down: freezing the
+// binding is worthless if the formatter behind it is guest-reachable.
+const __stringify = JSON.stringify;
+const __String = String;
+const __apply = Reflect.apply;
+const __strSlice = String.prototype.slice;
+
 function __jsonReplacer(_k, v) {
   if (v instanceof Error) return { name: v.name, message: v.message };
   if (typeof v === 'bigint') return v.toString() + 'n';
   return v;
 }
+// Indexed loop and \`+=\` rather than map/join: string concatenation is an
+// operator, not a lookup, so there is nothing here for the guest to replace.
+// What a guest CAN still steer is how its own values render - a \`toJSON\` or
+// \`toString\` on the object it passed - which is content it already owns, not
+// the channel.
 function __formatLine(args) {
-  const line = args.map(a => {
-    if (typeof a === 'string') return a;
-    if (a === undefined) return 'undefined';
-    if (a === null) return 'null';
-    try { return JSON.stringify(a, __jsonReplacer, 2); } catch { return String(a); }
-  }).join(' ');
+  let line = '';
+  for (let i = 0; i < args.length; i++) {
+    if (i > 0) line += ' ';
+    const a = args[i];
+    if (typeof a === 'string') { line += a; continue; }
+    if (a === undefined) { line += 'undefined'; continue; }
+    if (a === null) { line += 'null'; continue; }
+    try { line += __stringify(a, __jsonReplacer, 2); } catch { line += __String(a); }
+  }
   return line.length > HARD_PER_LINE_BYTES
-    ? line.slice(0, HARD_PER_LINE_BYTES) + ' [...line truncated]'
+    ? __apply(__strSlice, line, [0, HARD_PER_LINE_BYTES]) + ' [...line truncated]'
     : line;
 }
-globalThis.console = {
+// stdout is the channel the HOST reports back as the run's observation, so its
+// integrity is ours, not the guest's. A plain assignment left \`console\`
+// writable and configurable: guest code could set globalThis.console = {log(){}}
+// (or just reassign console.log) and every later run in the session would come
+// back with stdout="" or forged lines, error=null, and a clean listGlobals().
+// Frozen object + non-writable, non-configurable property: the guest's
+// assignment is a silent no-op in sloppy mode and a TypeError under 'use
+// strict', and either way capture keeps working.
+//
+// The BINDING is what this protects, and the binding is only half of it: a
+// frozen console whose formatter resolved its intrinsics at call time would
+// still hand the guest every line. That half is closed above, where
+// __formatLine captures what it needs.
+const __console = Object.freeze({
   log: (...a) => __cap.applySync(undefined, [__formatLine(a)], { arguments: { copy: true } }),
   warn: (...a) => __cap.applySync(undefined, [__formatLine(a)], { arguments: { copy: true } }),
   error: (...a) => __cap.applySync(undefined, [__formatLine(a)], { arguments: { copy: true } }),
   info: (...a) => __cap.applySync(undefined, [__formatLine(a)], { arguments: { copy: true } }),
-};
+});
+Object.defineProperty(globalThis, 'console', {
+  value: __console,
+  writable: false,
+  configurable: false,
+  enumerable: true,
+});
 
 // A bare isolate has no structuredClone (it's a host/web API, not a V8
 // intrinsic). The in-process + worker backends expose the *host's* real
@@ -13158,11 +13714,33 @@ for (const __Ctor of [__RealFunction, __AsyncFunction, __GeneratorFunction, __As
 globalThis.eval = __blockCodegen;
 globalThis.Function = __blockCodegen;
 
+// WebAssembly is removed, not stubbed. Its compile/instantiate promises never
+// settle inside an isolated-vm isolate (there is no host task runner to drive
+// them), so \`await WebAssembly.instantiate(...)\` is a one-line way for guest
+// code to park a run until the host deadline fires - and that deadline kills
+// the isolate, costing the whole session its sandbox. Deleting it turns that
+// into an immediate ReferenceError. It is also codegen-from-bytes, so it
+// belongs on the same side of the line as eval / Function anyway.
+delete globalThis.WebAssembly;
+
 // Tool-stub registry. Each registered tool becomes a top-level async
 // function that round-trips through the host dispatcher and re-throws on
 // the { ok:false } envelope.
+//
+// Assigned to globalThis only so the constructor can lift a Reference to it;
+// the constructor deletes the global immediately afterwards and calls it
+// through that Reference forever after. It must NOT stay guest-reachable: a
+// guest could call __registerTools(['console']) to overwrite the frozen
+// console binding with a tool stub, or \`delete\` it and make the host's next
+// setTools() throw.
+//
+// Indexed loop, not for..of, deliberately: the host calls this with a copied
+// array whose iterator comes from the GUEST's Array.prototype, so an
+// overridden Symbol.iterator would let guest code hang or hijack a host-side
+// setTools() call. Indexing touches only the copy's own properties.
 globalThis.__registerTools = function (names) {
-  for (const name of names) {
+  for (let i = 0; i < names.length; i++) {
+    const name = names[i];
     globalThis[name] = async (...args) => {
       const envJson = await __callTool.apply(
         undefined,
@@ -13175,6 +13753,7 @@ globalThis.__registerTools = function (names) {
     };
   }
 };
+})();
 `;
 z$1.object({
 	reflection: z$1.string().min(1),
@@ -15467,10 +16046,15 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	AnthropicBackend: () => AnthropicBackend,
 	AnthropicBatchService: () => AnthropicBatchService,
 	AnthropicBedrockBackend: () => AnthropicBedrockBackend,
+	BEDROCK_REQUEST_HANDLER: () => BEDROCK_REQUEST_HANDLER,
 	BFLBackend: () => BFLBackend,
 	BaseBedrockBackend: () => BaseBedrockBackend,
 	ChoiceEndReason: () => ChoiceEndReason,
 	ChoiceStatus: () => ChoiceStatus,
+	DEEPSEEK_EFFORT_LEVELS: () => DEEPSEEK_EFFORT_LEVELS,
+	DEEPSEEK_MAX_STOP_SEQUENCES: () => 16,
+	DEEPSEEK_MODELS: () => DEEPSEEK_MODELS,
+	DEEPSEEK_THINKING_TOP_P_FLOOR: () => DEEPSEEK_THINKING_TOP_P_FLOOR,
 	DEFAULT_MAX_TOOL_CALLS: () => 10,
 	DEFAULT_REALTIME_VOICE_MODEL: () => DEFAULT_REALTIME_VOICE_MODEL,
 	DEGENERATE_STREAM_MESSAGE: () => DEGENERATE_STREAM_MESSAGE,
@@ -15478,6 +16062,7 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	DEPRECATED_MODEL_MAP: () => DEPRECATED_MODEL_MAP,
 	DEPRECATED_MODEL_REQUEST_METRIC: () => DEPRECATED_MODEL_REQUEST_METRIC,
 	DISPATCHABLE_ADAPTER_FAMILIES: () => DISPATCHABLE_ADAPTER_FAMILIES,
+	DeepSeekBackend: () => DeepSeekBackend,
 	DeepSeekBedrockBackend: () => DeepSeekBedrockBackend,
 	DispatchModel: () => DispatchModel,
 	GeminiBackend: () => GeminiBackend,
@@ -15498,6 +16083,7 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	UndifferentiatedBedrockBackend: () => UndifferentiatedBedrockBackend,
 	UnsupportedAdapterFamilyError: () => UnsupportedAdapterFamilyError,
 	XAIBackend: () => XAIBackend,
+	adapterPriceTiers: () => adapterPriceTiers,
 	backendForAdapterFamily: () => backendForAdapterFamily,
 	buildApiKeyTable: () => buildApiKeyTable,
 	buildSupersededIndex: () => buildSupersededIndex,
@@ -15508,6 +16094,10 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	checkStaleModelReferences: () => checkStaleModelReferences,
 	classifyModelReference: () => classifyModelReference,
 	createDegenerateStreamGuard: () => createDegenerateStreamGuard,
+	deepseekReasoningParams: () => deepseekReasoningParams,
+	deepseekSamplingParams: () => deepseekSamplingParams,
+	deepseekStopSequences: () => deepseekStopSequences,
+	deepseekThinkingEnabled: () => deepseekThinkingEnabled,
 	ensureToolPairingIntegrity: () => ensureToolPairingIntegrity,
 	extractThinkContent: () => extractThinkContent,
 	getAvailableModels: () => getAvailableModels,
@@ -15524,6 +16114,7 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	logExpiringModels: () => logExpiringModels,
 	mergeCatalog: () => mergeCatalog,
 	mergeCatalogWithDrops: () => mergeCatalogWithDrops,
+	normalizeToolUseInputs: () => normalizeToolUseInputs,
 	reasonsWithinOutputBudget: () => reasonsWithinOutputBudget,
 	recordDeprecatedModelRequest: () => recordDeprecatedModelRequest,
 	replaceLastToolResultObservationCanonical: () => replaceLastToolResultObservationCanonical,
@@ -15541,6 +16132,7 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	splitCacheInclusiveInput: () => splitCacheInclusiveInput,
 	stripAllToolBlocks: () => stripAllToolBlocks,
 	stripToolDependentMessages: () => stripToolDependentMessages,
+	toDeepSeekEffort: () => toDeepSeekEffort,
 	toKimiEffort: () => toKimiEffort,
 	toProviderEndUserId: () => toProviderEndUserId,
 	updateReplacedByOverlay: () => updateReplacedByOverlay
@@ -15898,27 +16490,112 @@ const stripAllToolBlocks = (messages, logger) => {
 	return result;
 };
 /**
+* Restores `input: {}` on any `tool_use` block that reached us without one.
+*
+* `MessageContentToolUse.input` is non-optional in the type system, so nothing upstream checks it -
+* but a message that round-trips through a persistence or serialization layer can lose it. The
+* known offender is Mongoose's default `minimize`, which deletes empty objects on
+* `toObject()`/`toJSON()`: a zero-argument tool call (`current_datetime`, `mission_status`, ...)
+* stores `input: {}` and reads back with the key gone. Anthropic then rejects the whole request
+* with "messages.N.content.M.tool_use.input: Field required", killing a resumed agent run or a
+* chat turn that replays history.
+*
+* The schema that caused it is fixed at the source (`minimize: false` on AgentExecutionModel), so
+* this is the last line of defense for every other store that replays blocks verbatim -
+* `QuestModel.structuredReplies[].content` is the same Mixed-under-default-minimize shape and is
+* deliberately covered here rather than by widening that hot collection's schema. The cost of a
+* miss is a hard 400, and `{}` is the only value a zero-argument call could have had.
+*
+* Returns the input array unchanged (same reference) when nothing needed repair.
+*/
+const normalizeToolUseInputs = (messages, logger) => {
+	let repaired = 0;
+	const result = messages.map((message) => {
+		if (!Array.isArray(message.content)) return message;
+		let messageChanged = false;
+		const content = message.content.map((block) => {
+			if (block.type !== "tool_use") return block;
+			const toolUse = block;
+			if (toolUse.input !== null && typeof toolUse.input === "object") return block;
+			repaired++;
+			messageChanged = true;
+			return {
+				...toolUse,
+				input: {}
+			};
+		});
+		return messageChanged ? {
+			...message,
+			content
+		} : message;
+	});
+	if (repaired === 0) return messages;
+	logger?.warn(`[Tool Input Repair] Restored empty input on ${repaired} tool_use block(s) that lost it in serialization`);
+	return result;
+};
+/**
+* Anthropic's hard ceiling on `cache_control` markers per request. Exceeding it fails the
+* WHOLE request with `ValidationException: A maximum of 4 blocks with cache_control may be
+* provided`, which is non-retryable - so an over-budget request loses the turn outright,
+* after the user has already waited for it.
+*/
+const MAX_CACHE_CONTROL_BLOCKS = 4;
+/**
+* Does this block already carry a marker? Re-marking one costs no budget.
+*
+* Tests the VALUE, not just key presence: a block carrying an explicit
+* `cache_control: undefined` is not a marker as far as the provider is concerned, and counting
+* it would spend budget on nothing and drop a breakpoint we could have kept.
+*/
+function hasMarker(block) {
+	return !!block && typeof block === "object" && !!block.cache_control;
+}
+/**
+* Markers already on the request. Callers upstream attach their own before this runs -
+* `bedrockBackend/anthropic.ts` marks each system block flagged `cache: true` (the mid-stack
+* shareable-prefix breakpoint) - so this adapter's budget is whatever they left, not the full four.
+*/
+function censusMarkers(params) {
+	const tools = Array.isArray(params.tools) ? params.tools.filter(hasMarker).length : 0;
+	const system = Array.isArray(params.system) ? params.system.filter(hasMarker).length : 0;
+	let messages = 0;
+	if (Array.isArray(params.messages)) for (const message of params.messages) {
+		const content = message?.content;
+		if (Array.isArray(content)) messages += content.filter(hasMarker).length;
+	}
+	return {
+		tools,
+		system,
+		messages,
+		total: tools + system + messages
+	};
+}
+/**
 * Anthropic-specific caching adapter
 * Adds explicit cache_control markers to content blocks
 */
 var AnthropicCachingAdapter = class {
-	applyCaching(apiParams, strategy) {
+	applyCaching(apiParams, strategy, logger) {
 		if (!strategy.enableCaching) return apiParams;
 		const ttl = strategy.cacheTTL ?? "5m";
 		const modifiedParams = { ...apiParams };
-		const tools = modifiedParams.tools;
-		if (strategy.cacheTools && Array.isArray(tools) && tools.length > 0) {
-			const toolsCopy = [...tools];
-			const lastTool = toolsCopy[toolsCopy.length - 1];
-			toolsCopy[toolsCopy.length - 1] = {
-				...lastTool,
-				cache_control: {
-					type: "ephemeral",
-					...ttl === "1h" ? { ttl } : {}
-				}
-			};
-			modifiedParams.tools = toolsCopy;
-		}
+		const cacheControl = {
+			type: "ephemeral",
+			...ttl === "1h" ? { ttl } : {}
+		};
+		const inbound = censusMarkers(modifiedParams);
+		let budget = MAX_CACHE_CONTROL_BLOCKS - inbound.total;
+		const dropped = [];
+		/** Claim one marker slot, or record the miss. Re-marking a marked block is free. */
+		const claim = (name, alreadyMarked) => {
+			if (alreadyMarked) return true;
+			if (budget <= 0) {
+				dropped.push(name);
+				return false;
+			}
+			budget -= 1;
+			return true;
+		};
 		const systemParam = modifiedParams.system;
 		if (strategy.cacheSystemPrompt && systemParam) {
 			const systemArray = Array.isArray(systemParam) ? [...systemParam] : [{
@@ -15927,14 +16604,13 @@ var AnthropicCachingAdapter = class {
 			}];
 			if (systemArray.length > 0) {
 				const lastBlock = systemArray[systemArray.length - 1];
-				systemArray[systemArray.length - 1] = {
-					...lastBlock,
-					cache_control: {
-						type: "ephemeral",
-						...ttl === "1h" ? { ttl } : {}
-					}
-				};
-				modifiedParams.system = systemArray;
+				if (claim("system", hasMarker(lastBlock))) {
+					systemArray[systemArray.length - 1] = {
+						...lastBlock,
+						cache_control: cacheControl
+					};
+					modifiedParams.system = systemArray;
+				}
 			}
 		}
 		const messagesParam = modifiedParams.messages;
@@ -15950,24 +16626,65 @@ var AnthropicCachingAdapter = class {
 					text: msgContent
 				}];
 				else if (Array.isArray(msgContent)) contentArray = [...msgContent];
-				else return modifiedParams;
-				if (contentArray.length > 0) {
+				if (contentArray && contentArray.length > 0) {
 					const lastBlock = contentArray[contentArray.length - 1];
-					contentArray[contentArray.length - 1] = {
-						...lastBlock,
-						cache_control: {
-							type: "ephemeral",
-							...ttl === "1h" ? { ttl } : {}
-						}
-					};
-					messages[anchorIndex] = {
-						...anchorMsg,
-						content: contentArray
-					};
-					modifiedParams.messages = messages;
+					if (claim("history", hasMarker(lastBlock))) {
+						contentArray[contentArray.length - 1] = {
+							...lastBlock,
+							cache_control: cacheControl
+						};
+						messages[anchorIndex] = {
+							...anchorMsg,
+							content: contentArray
+						};
+						modifiedParams.messages = messages;
+					}
 				}
 			}
 		}
+		const tools = modifiedParams.tools;
+		if (strategy.cacheTools && Array.isArray(tools) && tools.length > 0) {
+			const toolsCopy = [...tools];
+			const lastTool = toolsCopy[toolsCopy.length - 1];
+			if (claim("tools", hasMarker(lastTool))) {
+				toolsCopy[toolsCopy.length - 1] = {
+					...lastTool,
+					cache_control: cacheControl
+				};
+				modifiedParams.tools = toolsCopy;
+			}
+		}
+		const outbound = censusMarkers(modifiedParams);
+		const census = {
+			inbound,
+			outbound,
+			limit: MAX_CACHE_CONTROL_BLOCKS
+		};
+		if (outbound.total >= MAX_CACHE_CONTROL_BLOCKS) {
+			const message = "[PromptCache] cache_control census at the ceiling";
+			if (logger) logger.info(message, census);
+			else console.info(message, JSON.stringify(census));
+		} else if (logger) logger.debug("[PromptCache] cache_control census", census);
+		if (outbound.total > MAX_CACHE_CONTROL_BLOCKS) {
+			const message = `[PromptCache] request exceeds the ${MAX_CACHE_CONTROL_BLOCKS}-block cache_control limit on arrival (${outbound.total}); the provider will reject it`;
+			const detail = {
+				inbound,
+				outbound,
+				limit: MAX_CACHE_CONTROL_BLOCKS
+			};
+			if (logger) logger.error(message, detail);
+			else console.error(message, JSON.stringify(detail));
+		} else if (dropped.length > 0) {
+			const message = `[PromptCache] cache_control budget exhausted (limit ${MAX_CACHE_CONTROL_BLOCKS}); skipped breakpoints: ${dropped.join(", ")}`;
+			const detail = {
+				dropped,
+				inbound,
+				outbound,
+				limit: MAX_CACHE_CONTROL_BLOCKS
+			};
+			if (logger) logger.warn(message, detail);
+			else console.warn(message, JSON.stringify(detail));
+		}
 		return modifiedParams;
 	}
 	extractCacheStats(response, model) {
@@ -16131,6 +16848,92 @@ var KimiCachingAdapter = 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`, Moonshot publishes a flat
+* `cached_tokens` alongside the OpenAI-shaped nesting, and DeepSeek its own flat
+* `prompt_cache_hit_tokens`. Reading only one spelling silently bills every cache
+* hit on the other transports at the full input rate.
+*
+* DeepSeek's own spelling leads, because it is the number its invoice is computed
+* from; the OpenAI-shaped ones it also sends are the fallback for a proxy that
+* forwards only those.
+*/
+function cachedTokensFromUsage(usage) {
+	if (!usage) return 0;
+	const candidates = [
+		usage.prompt_cache_hit_tokens,
+		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;
+}
+/**
+* DeepSeek context caching. Automatic, like Moonshot's and xAI's: no parameter,
+* no header, no explicit cache-creation call. The adapter exists only to read
+* the counters back out.
+* @see https://api-docs.deepseek.com/guides/kv_cache
+*/
+var DeepSeekCachingAdapter = class {
+	applyCaching(apiParams, _strategy) {
+		return apiParams;
+	}
+	extractCacheStats(response, model) {
+		const usage = response.usage;
+		if (!usage) return void 0;
+		const totalInputTokens = usage.prompt_tokens || 0;
+		const cachedTokens = cachedTokensFromUsage(usage);
+		const cacheHitRate = totalInputTokens > 0 ? cachedTokens / totalInputTokens * 100 : 0;
+		const costSavingsPercent = cacheHitRate * .98;
+		const estimatedLatencyReduction = cacheHitRate * .7;
+		return {
+			provider: ModelBackend.DeepSeek,
+			model,
+			totalInputTokens,
+			cacheReadTokens: cachedTokens,
+			cacheWriteTokens: 0,
+			uncachedTokens: Math.max(0, totalInputTokens - cachedTokens),
+			cacheHitRate,
+			costSavingsPercent,
+			estimatedLatencyReduction,
+			providerMetadata: { automatic: true }
+		};
+	}
+};
+/**
 * Helper to log cache statistics in a consistent format across all providers
 */
 function logCacheStats(logger, cacheStats, options) {
@@ -16164,6 +16967,7 @@ const ADAPTERS = {
 	[ModelBackend.Bedrock]: new AnthropicCachingAdapter(),
 	[ModelBackend.XAI]: new XAICachingAdapter(),
 	[ModelBackend.Kimi]: new KimiCachingAdapter(),
+	[ModelBackend.DeepSeek]: new DeepSeekCachingAdapter(),
 	[ModelBackend.Ollama]: new NoOpCachingAdapter(),
 	[ModelBackend.BFL]: new NoOpCachingAdapter(),
 	[ModelBackend.VoyageAI]: new NoOpCachingAdapter(),
@@ -16214,14 +17018,28 @@ const ADAPTIVE_THINKING_MAX_TOKENS_FLOOR = 64e3;
 const THINKING_ANSWER_HEADROOM_TOKENS = 1e3;
 /**
 * Reasoning-inside-the-budget ids that none of the shape checks below can infer.
+*
 * Bedrock's Kimi always reasons, but it is not Anthropic-adaptive, does not take
 * `reasoning_effort`, and sends plain `max_tokens` - so it looks like an ordinary
 * model at every seam we can inspect. Bedrock copies the monologue inline into
 * `content` (see bedrockBackend/moonshot.ts) and caps output at 16K, so the floor
 * resolves to that entire cap, which is the only value leaving room for an answer
 * after a long trace.
-*/
-const REASONS_WITHIN_OUTPUT_BUDGET_IDS = /* @__PURE__ */ new Set([ChatModels.KIMI_K2_THINKING_BEDROCK, ChatModels.KIMI_K2_5_BEDROCK]);
+*
+* DeepSeek Flash misses every clause for its own set of reasons: no
+* `thinkingStyle` (that field is Anthropic's), absent from the OpenAI-only
+* REASONING_SUPPORTED_MODELS, and DEEPSEEK_PROFILE declares plain `max_tokens`
+* rather than `max_completion_tokens` because that is the parameter DeepSeek
+* takes. It reasons on every turn by default at effort 'high', spends those
+* tokens inside `max_tokens`, and a 4096 budget against a 393K cap is consumed
+* by the monologue alone: the turn comes back `finish_reason: 'length'` with no
+* content and deepseekBackend throws.
+*/
+const REASONS_WITHIN_OUTPUT_BUDGET_IDS = /* @__PURE__ */ new Set([
+	ChatModels.KIMI_K2_THINKING_BEDROCK,
+	ChatModels.KIMI_K2_5_BEDROCK,
+	ChatModels.DEEPSEEK_FLASH
+]);
 /**
 * Whether the model spends reasoning tokens inside its output budget on every turn,
 * which is what makes a small budget produce an empty visible reply rather than a
@@ -16737,7 +17555,7 @@ var AnthropicBackend = class {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 2,
 				trainingCutoff: "2024-10-01",
 				releaseDate: "2025-05-23",
 				deprecationDate: "2026-06-01",
@@ -16760,7 +17578,7 @@ var AnthropicBackend = class {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 2,
 				trainingCutoff: "2025-07-01",
 				releaseDate: "2025-09-30",
 				description: "Anthropic's most intelligent model in the Claude 4 family. Delivers exceptional performance across coding, analysis, and complex reasoning tasks with improved speed and efficiency. Ideal for production workloads requiring both power and reliability."
@@ -16780,7 +17598,7 @@ var AnthropicBackend = class {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 3,
 				supportsTools: true,
 				trainingCutoff: "2025-07-01",
 				releaseDate: "2025-10-16",
@@ -16827,7 +17645,7 @@ var AnthropicBackend = class {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 2,
 				trainingCutoff: "2025-10-01",
 				releaseDate: "2026-02-19",
 				description: "Anthropic's Claude 4.6 Sonnet model. Delivers enhanced performance across coding, analysis, and complex reasoning tasks with improved speed and efficiency."
@@ -16850,7 +17668,7 @@ var AnthropicBackend = class {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "Anthropic_logo.png",
-				rank: 0,
+				rank: 1,
 				trainingCutoff: "2026-01-01",
 				releaseDate: "2026-07-01",
 				description: "Anthropic's newest Claude 5 Sonnet model. Near-Opus quality on coding and agentic work at Sonnet cost, with adaptive extended thinking and a 1M-token context window."
@@ -16943,7 +17761,7 @@ var AnthropicBackend = class {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 0,
 				supportsTools: true,
 				trainingCutoff: "2026-01-01",
 				releaseDate: "2026-07-01",
@@ -16967,7 +17785,7 @@ var AnthropicBackend = class {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 0,
 				supportsTools: true,
 				releaseDate: "2026-07-24",
 				description: "Anthropic's latest flagship model. Claude 5 Opus approaches Fable 5 performance at Opus 4.8 pricing, with adaptive extended thinking, coding, and agentic capabilities.",
@@ -17095,7 +17913,7 @@ var AnthropicBackend = class {
 			const parts = [this.consolidateSystemMessages(messages), identityReminder].filter(Boolean);
 			system = parts.length > 0 ? parts.join("\n") : void 0;
 		}
-		let filteredMessages = ensureToolPairingIntegrity(this.filterRelevantMessages(cacheStampedMessages), this.logger);
+		let filteredMessages = normalizeToolUseInputs(ensureToolPairingIntegrity(this.filterRelevantMessages(cacheStampedMessages), this.logger), this.logger);
 		const countToolBlocks = (msgs) => {
 			let useCount = 0;
 			let resultCount = 0;
@@ -17195,7 +18013,7 @@ var AnthropicBackend = class {
 		} else this.isThinkingEnabled = false;
 		const cacheStrategy = options.cacheStrategy;
 		if (cacheStrategy?.enableCaching) {
-			const cachedParams = getCachingAdapter(ModelBackend.Anthropic).applyCaching(apiParams, cacheStrategy);
+			const cachedParams = getCachingAdapter(ModelBackend.Anthropic).applyCaching(apiParams, cacheStrategy, this.logger);
 			Object.assign(apiParams, cachedParams);
 			this.logger.debug("[Anthropic] Applying cache control", {
 				cacheSystemPrompt: cacheStrategy.cacheSystemPrompt,
@@ -18219,6 +19037,11 @@ const BEDROCK_RETRY_CONFIG = {
 	maxAttempts: 6,
 	retryMode: "adaptive"
 };
+const BEDROCK_REQUEST_HANDLER = {
+	requestTimeout: 12e4,
+	sessionTimeout: 13e4,
+	disableConcurrentStreams: true
+};
 /**
 * Detect cancellation errors so they propagate past tool-error containment to
 * the outer catch (which has dedicated abort handling). Without this, aborts
@@ -18260,7 +19083,8 @@ var BaseBedrockBackend = class {
 		};
 		this._bedrockRuntime = new BedrockRuntimeClient({
 			region: this._options.region,
-			...BEDROCK_RETRY_CONFIG
+			...BEDROCK_RETRY_CONFIG,
+			requestHandler: BEDROCK_REQUEST_HANDLER
 		});
 	}
 	getRegionForModel(model) {
@@ -18290,12 +19114,31 @@ var BaseBedrockBackend = class {
 	takeReasoningBlocks() {
 		return [];
 	}
+	/**
+	* Whether this adapter's `translateStreamChunk` reports `done: true` ONLY on the provider's
+	* terminal event. When true, complete() treats a stream that produced output but never
+	* reported done as a TRUNCATED response and throws instead of returning the partial text.
+	*
+	* Opt-in rather than the default because "reports done terminally" is a per-adapter contract
+	* the base class cannot infer, and getting it wrong turns every healthy completion into an
+	* error. Three groups exist today:
+	*   - terminal-only, so they override this to true: anthropic, deepseek, llama, jurassicTwo
+	*   - `done: true` on EVERY content chunk, so the check would be inert: titan, moonshot
+	*     (the better fix for those is a stopReason passthrough, as moonshot.ts already does)
+	*   - never report done, incl. the test doubles in this directory: left false
+	*
+	* A new streaming backend must opt in deliberately; silence keeps the old behaviour.
+	*/
+	get signalsStreamTermination() {
+		return false;
+	}
 	updateClientForModel(model) {
 		const requiredRegion = this.getRegionForModel(model);
 		this._options.region = requiredRegion;
 		this._bedrockRuntime = new BedrockRuntimeClient({
 			region: this._options.region,
-			...BEDROCK_RETRY_CONFIG
+			...BEDROCK_RETRY_CONFIG,
+			requestHandler: BEDROCK_REQUEST_HANDLER
 		});
 	}
 	async complete(model, messages, options, callback, toolsUsed = []) {
@@ -18403,9 +19246,11 @@ var BaseBedrockBackend = class {
 				if (!response.body) throw new Error("No response body");
 				const func = [];
 				let emittedTextChars = 0;
+				let sawTerminalEvent = false;
 				for await (const streamEvent of response.body) if (streamEvent.chunk?.bytes) {
 					const json = new TextDecoder().decode(streamEvent.chunk.bytes);
-					const { chunk } = this.translateStreamChunk(model, JSON.parse(json));
+					const { done, chunk } = this.translateStreamChunk(model, JSON.parse(json));
+					sawTerminalEvent ||= done;
 					if (chunk?.stopReason) stopReason = chunk.stopReason;
 					chunk?.choices?.forEach((choice) => {
 						func[choice.index] ||= {};
@@ -18429,6 +19274,7 @@ var BaseBedrockBackend = class {
 					await callback(streamedText, buildCompletionInfo());
 				}
 				if (emittedTextChars === 0 && !func.some((f) => f.name)) throw new Error(`[BaseBedrockBackend] model "${model}" returned an EMPTY response in region ${this._options.region} (no text, no tool call, no output tokens). A "global." cross-region inference profile served from a region that does not host it does exactly this - try the "us." variant, or confirm the model/profile is granted in ${this._options.region}.`);
+				if (this.signalsStreamTermination && !sawTerminalEvent && !options.abortSignal?.aborted) throw new Error(`[BaseBedrockBackend] stream timeout - model "${model}" in region ${this._options.region} ended after ${emittedTextChars} chars without a terminal event, so the response is TRUNCATED. Usually a stalled Bedrock socket cut the stream short; the partial text is withheld deliberately rather than returned as a finished answer.`);
 				if (func.some((f) => f.name)) {
 					for await (const tool of func) {
 						const { id, name, parameters } = tool;
@@ -18733,6 +19579,10 @@ const TEMPERATURE_ONLY_MODELS = [
 	ChatModels.CLAUDE_4_6_OPUS_BEDROCK
 ];
 var AnthropicBedrockBackend = class extends BaseBedrockBackend {
+	/** Reports done only on message_stop (anthropic.ts translateStreamChunk), so a missing terminal event means a truncated stream. */
+	get signalsStreamTermination() {
+		return true;
+	}
 	isInThinkingBlock = false;
 	/**
 	* Reasoning blocks of the assistant turn currently being translated, indexed by the
@@ -18780,7 +19630,11 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 		if (NO_TEMPERATURE_MODELS.has(model)) return true;
 		return !this.getModelInfoList().some((m) => m.id === model) && this._dispatch.for(model)?.thinkingStyle === "adaptive";
 	}
-	/** Static model info list - synchronous access for getPayload, also used by getModelInfo */
+	/**
+	* Static model info list - synchronous access for getPayload, also used by getModelInfo.
+	* `rank` must match the identically-named entry in anthropicBackend.ts: it is the same
+	* model, so the picker must not show the Bedrock copy above or below its direct twin.
+	*/
 	getModelInfoList() {
 		return [
 			{
@@ -18904,7 +19758,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 0,
+				rank: 1,
 				supportsTools: true,
 				trainingCutoff: "2025-05-01",
 				releaseDate: "2025-05-23",
@@ -18927,7 +19781,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 0,
+				rank: 1,
 				supportsTools: true,
 				trainingCutoff: "2025-08-01",
 				releaseDate: "2025-08-06",
@@ -18950,7 +19804,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 2,
 				supportsTools: true,
 				trainingCutoff: "2025-05-01",
 				releaseDate: "2025-05-23",
@@ -18973,7 +19827,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 2,
 				trainingCutoff: "2025-07-01",
 				releaseDate: "2025-09-30",
 				description: "Anthropic's most intelligent model hosted in AWS Bedrock. Delivers exceptional performance across coding, analysis, and complex reasoning tasks with improved speed and efficiency. Ideal for production workloads requiring both power and reliability."
@@ -18993,7 +19847,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 3,
 				supportsTools: true,
 				trainingCutoff: "2025-07-01",
 				releaseDate: "2025-10-16",
@@ -19040,7 +19894,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "Anthropic_logo.png",
-				rank: 1,
+				rank: 2,
 				trainingCutoff: "2025-10-01",
 				releaseDate: "2026-02-19",
 				description: "Anthropic's Claude 4.6 Sonnet model via AWS Bedrock. Delivers enhanced performance across coding, analysis, and complex reasoning tasks with improved speed and efficiency."
@@ -19063,7 +19917,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "Anthropic_logo.png",
-				rank: 0,
+				rank: 1,
 				trainingCutoff: "2026-01-01",
 				releaseDate: "2026-07-01",
 				description: "Anthropic's newest Claude 5 Sonnet model via AWS Bedrock. Near-Opus quality on coding and agentic work at Sonnet cost, with adaptive extended thinking and a 1M-token context window."
@@ -19084,7 +19938,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 0,
+				rank: 1,
 				supportsTools: true,
 				trainingCutoff: "2025-05-01",
 				releaseDate: "2026-02-06",
@@ -19108,7 +19962,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 0,
+				rank: 1,
 				supportsTools: true,
 				trainingCutoff: "2025-10-01",
 				releaseDate: "2026-04-17",
@@ -19132,7 +19986,7 @@ var AnthropicBedrockBackend = class extends BaseBedrockBackend {
 				} },
 				supportsVision: true,
 				logoFile: "Anthropic_logo.png",
-				rank: 0,
+				rank: 1,
 				supportsTools: true,
 				trainingCutoff: "2026-01-01",
 				releaseDate: "2026-05-28",
@@ -19495,6 +20349,10 @@ function isReasoningBlock(block) {
 	return "reasoningContent" in block;
 }
 var DeepSeekBedrockBackend = class extends BaseBedrockBackend {
+	/** Reports done only on event.messageStop, so a missing terminal event means a truncated stream. */
+	get signalsStreamTermination() {
+		return true;
+	}
 	/** Suppresses reasoning/thinking output for summary and title generation calls. */
 	isSpecialTask = false;
 	/** Tracks whether the stream is currently inside a reasoning span, to emit one <think>/</think> pair per span. */
@@ -19784,7 +20642,7 @@ var JurassicTwoBedrockBackend = class extends BaseBedrockBackend {
 			} },
 			supportsVision: false,
 			logoFile: "AI21Labs.png",
-			rank: 50,
+			rank: 51,
 			description: "AI21 Labs' balanced Jurassic-2 model offering good performance at moderate cost. Great for everyday tasks and general content generation."
 		}];
 	}
@@ -19839,6 +20697,10 @@ var JurassicTwoBedrockBackend = class extends BaseBedrockBackend {
 	}
 };
 var LlamaBedrockBackend = class extends BaseBedrockBackend {
+	/** Reports done only on response.stop_reason on the terminal chunk, so a missing terminal event means a truncated stream. */
+	get signalsStreamTermination() {
+		return true;
+	}
 	async getModelInfo() {
 		return [
 			{
@@ -20876,7 +21738,7 @@ var GeminiBackend = class {
 				supportsVision: true,
 				supportsTools: true,
 				logoFile: "Google_logo.png",
-				rank: 5,
+				rank: 6,
 				trainingCutoff: "2025-01-31",
 				releaseDate: "2025-11-30",
 				description: "Google's Gemini 3 Flash preview for fast, low-latency multimodal understanding, delivering richer visuals and deeper interactivity, built on a foundation of state-of-the-art reasoning."
@@ -20984,7 +21846,7 @@ var GeminiBackend = class {
 				rank: 8,
 				trainingCutoff: "2025-01-31",
 				releaseDate: "2025-06-01",
-				deprecationDate: "2026-10-16",
+				deprecationDate: "2026-09-02",
 				description: "Google's Gemini 2.5 Flash, offering well-rounded price-performance. Best for large scale processing, low-latency, high volume tasks that require thinking, and agentic use cases"
 			},
 			{
@@ -21632,112 +22494,38 @@ 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.
+* Request shaping for DeepSeek's direct API. Kept out of deepseekBackend's
+* transport for the same reason kimiParams is: every "which parameter does this
+* id accept" rule is one pure function with a test next to it, rather than a
+* conditional buried in a 400-line complete().
 *
-* 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.
+* DeepSeek is OpenAI-compatible in envelope. What differs is thinking mode -
+* on by default, with its own toggle, its own effort vocabulary, and a sampling
+* group that is IGNORED rather than rejected while it is on.
+* @see https://api-docs.deepseek.com/guides/thinking_mode
 */
-/**
-* 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().
-*
-* Moonshot is OpenAI-compatible in envelope only. The reasoning controls, the
-* sampling pins, and the max-tokens parameter all differ per model, and sending
-* the wrong one is a 400 rather than a silently ignored field.
-* @see https://platform.kimi.ai/docs/api/chat
-*/
-/** Kimi's own effort vocabulary, which is not OpenAI's and not B4M's. */
-const KIMI_EFFORT_LEVELS = [
+/** DeepSeek's effort vocabulary, which is not OpenAI's and not B4M's. */
+const DEEPSEEK_EFFORT_LEVELS = [
 	"low",
 	"high",
 	"max"
 ];
 /**
-* Takes `reasoning_effort`. K3 only, and K3 always reasons - there is no way to
-* turn thinking off, so the parameter selects depth, never whether.
+* Every DeepSeek id this build ships, direct-served. Bedrock-served DeepSeek is
+* not here. Both the reasoning and the sampling shaper gate on THIS set, so the
+* two cannot disagree about which ids the rules apply to; a test pins it against
+* the adapter table and against NO_TEMPERATURE_MODELS.
 */
-const EFFORT_MODELS = /* @__PURE__ */ new Set([ChatModels.KIMI_K3]);
-/** Takes the `thinking` object instead of `reasoning_effort`. */
-const THINKING_MODELS = /* @__PURE__ */ new Set([
-	ChatModels.KIMI_K2_7_CODE,
-	ChatModels.KIMI_K2_7_CODE_HIGHSPEED,
-	ChatModels.KIMI_K2_6,
-	ChatModels.KIMI_K2_5
-]);
-/**
-* `thinking.type` accepts only 'enabled' on the K2.7 code models - 'disabled' is
-* rejected. So a caller asking for no thinking gets thinking anyway; the
-* alternative is a 400, and the parameter is omitted rather than fought.
-*/
-const THINKING_ALWAYS_ON = /* @__PURE__ */ new Set([ChatModels.KIMI_K2_7_CODE, ChatModels.KIMI_K2_7_CODE_HIGHSPEED]);
-/**
-* Rejects `tool_choice: 'required'` (auto and none are fine, as is the explicit
-* function form). Downgraded to 'auto' rather than dropped: a caller that asked
-* for a forced tool still wants tools offered.
-*/
-const NO_REQUIRED_TOOL_CHOICE = /* @__PURE__ */ new Set([
-	ChatModels.KIMI_K2_7_CODE,
-	ChatModels.KIMI_K2_7_CODE_HIGHSPEED,
-	ChatModels.KIMI_K2_6
-]);
-/** Every Kimi id this build ships, direct-served. Bedrock-served Kimi is not here. */
-const KIMI_MODELS = /* @__PURE__ */ new Set([
-	ChatModels.KIMI_K3,
-	ChatModels.KIMI_K2_7_CODE,
-	ChatModels.KIMI_K2_7_CODE_HIGHSPEED,
-	ChatModels.KIMI_K2_6,
-	ChatModels.KIMI_K2_5
-]);
+const DEEPSEEK_MODELS = /* @__PURE__ */ new Set([ChatModels.DEEPSEEK_FLASH]);
+/** DeepSeek raises anything below this rather than erroring, so we send what it will use. */
+const DEEPSEEK_THINKING_TOP_P_FLOOR = .95;
 /**
-* B4M's six-level effort onto Kimi's three. 'none' and 'minimal' map to 'low'
-* rather than to omission because K3 cannot be asked not to think - claiming
-* otherwise by dropping the parameter would silently bill max-effort reasoning
-* (Moonshot's default is 'max').
+* B4M's six-level effort onto DeepSeek's three. 'none' and 'minimal' map to
+* 'low' rather than to omission: omitting the parameter leaves DeepSeek's
+* documented default of 'high', so dropping it on a "least effort" request
+* would bill more reasoning than was asked for, not less.
 */
-function toKimiEffort(effort) {
+function toDeepSeekEffort(effort) {
 	if (!effort) return void 0;
 	switch (effort) {
 		case "none":
@@ -21751,48 +22539,66 @@ function toKimiEffort(effort) {
 }
 /**
 * The reasoning parameters for one model, or an empty object when it takes none.
-* Mutually exclusive by construction: no Kimi model accepts both spellings, and
-* sending both is a 400.
+*
+* Both spellings are OpenAI-format and independent, unlike Kimi where they are
+* mutually exclusive: `thinking.type` turns reasoning on or off and
+* `reasoning_effort` sets its depth. DeepSeek's own example sends both in one
+* request. Omitting both leaves thinking enabled at effort 'high'.
 */
-function kimiReasoningParams(model, input) {
-	if (EFFORT_MODELS.has(model)) {
-		const effort = toKimiEffort(input.reasoningEffort);
-		return effort ? { reasoning_effort: effort } : {};
-	}
-	if (THINKING_MODELS.has(model)) {
-		if (THINKING_ALWAYS_ON.has(model)) return { thinking: { type: "enabled" } };
-		if (input.thinking?.enabled === void 0) return {};
-		return { thinking: { type: input.thinking.enabled ? "enabled" : "disabled" } };
-	}
-	return {};
+function deepseekReasoningParams(model, input = {}) {
+	if (!DEEPSEEK_MODELS.has(model)) return {};
+	const params = {};
+	if (input.thinking?.enabled !== void 0) params.thinking = { type: input.thinking.enabled ? "enabled" : "disabled" };
+	if (input.thinking?.enabled === false) return params;
+	const effort = toDeepSeekEffort(input.reasoningEffort);
+	if (effort) params.reasoning_effort = effort;
+	return params;
 }
 /**
-* Sampling parameters for one model. Moonshot pins temperature (1.0) and top_p
-* (0.95) on every current Kimi and documents them as unmodifiable, so they are
-* omitted rather than sent-and-ignored; NO_TEMPERATURE_MODELS is the shared set
-* the catalog's temperatureMode also lands on.
+* Whether the turn will reason, which is what the sampling restrictions below
+* actually hang on. DeepSeek's default is enabled, so only an explicit
+* `thinking.enabled === false` turns it off.
+*/
+function deepseekThinkingEnabled(input = {}) {
+	return input.thinking?.enabled !== false;
+}
+/**
+* Sampling parameters for one turn.
 *
-* The penalties and `n` ride the same gate. Moonshot documents the whole sampling
-* group as fixed on these ids, B4M sends penalties on essentially every turn, and
-* an unmodifiable parameter here is a 400 rather than a silently ignored field -
-* so the conservative reading is the safe one. Only the moonshot-v1 family, which
-* this build does not ship, accepts any of them.
+* In thinking mode - the default - DeepSeek documents temperature,
+* presence_penalty and frequency_penalty as unsupported. They are accepted and
+* SILENTLY ignored rather than rejected, which is the worse failure of the two:
+* a 400 tells you the knob is dead, a no-op does not. They are dropped here so
+* nothing is sent that cannot take effect.
+*
+* Keyed on the TURN's resolved thinking state, not on model id: the restriction
+* is a property of thinking mode and the caller can turn thinking off, in which
+* case dropping temperature anyway would reproduce the same silent no-op from
+* our side of the wire.
+*
+* `top_p` does work in thinking mode with a lower bound of 0.95: a smaller value
+* is raised to it. Sent clamped rather than dropped, so the request states the
+* value the server will actually apply. The floor is a thinking-mode rule, so it
+* does not apply once thinking is off.
+*
+* `n` is not in DeepSeek's schema in either mode and is never sent.
 */
-function kimiSamplingParams(model, input) {
-	if (NO_TEMPERATURE_MODELS.has(model)) return {};
-	const params = {};
-	if (input.temperature !== void 0) params.temperature = input.temperature;
-	if (input.topP !== void 0) params.top_p = input.topP;
-	if (input.presencePenalty !== void 0) params.presence_penalty = input.presencePenalty;
-	if (input.frequencyPenalty !== void 0) params.frequency_penalty = input.frequencyPenalty;
-	if (input.n !== void 0) params.n = input.n;
-	return params;
+function deepseekSamplingParams(model, input, reasoning = {}) {
+	if (!DEEPSEEK_MODELS.has(model) || !deepseekThinkingEnabled(reasoning)) {
+		const passthrough = {};
+		if (input.temperature !== void 0) passthrough.temperature = input.temperature;
+		if (input.topP !== void 0) passthrough.top_p = input.topP;
+		if (input.presencePenalty !== void 0) passthrough.presence_penalty = input.presencePenalty;
+		if (input.frequencyPenalty !== void 0) passthrough.frequency_penalty = input.frequencyPenalty;
+		return passthrough;
+	}
+	if (input.topP === void 0) return {};
+	return { top_p: Math.max(input.topP, DEEPSEEK_THINKING_TOP_P_FLOOR) };
 }
-/** `tool_choice`, downgraded to 'auto' on the ids that reject 'required'. */
-function kimiToolChoice(model, choice) {
-	if (choice === void 0) return void 0;
-	if (choice === "required" && NO_REQUIRED_TOOL_CHOICE.has(model)) return "auto";
-	return choice;
+/** `stop`, truncated to the 16 sequences DeepSeek accepts. */
+function deepseekStopSequences(stop) {
+	if (!Array.isArray(stop)) return stop;
+	return stop.length > 16 ? stop.slice(0, 16) : stop;
 }
 /** Type guard: does this message already carry OpenAI-style `tool_calls`? */
 function hasToolCalls(msg) {
@@ -21815,12 +22621,16 @@ function isTextBlock(block) {
 * Messages already in OpenAI format (with `tool_calls` property) pass through unchanged.
 * Messages without tool_use/tool_result content blocks pass through unchanged.
 */
-function convertMessageToOpenAIFormat(msg) {
-	if (hasToolCalls(msg)) return [{
-		role: "assistant",
-		content: null,
-		tool_calls: msg.tool_calls
-	}];
+function convertMessageToOpenAIFormat(msg, options = {}) {
+	if (hasToolCalls(msg)) {
+		const reasoningContent = msg.reasoning_content;
+		return [{
+			role: "assistant",
+			content: null,
+			tool_calls: msg.tool_calls,
+			...options.preserveReasoningContent && typeof reasoningContent === "string" ? { reasoning_content: reasoningContent } : {}
+		}];
+	}
 	if (msg.role === "assistant" && Array.isArray(msg.content)) {
 		const contentBlocks = msg.content;
 		const toolUseBlocks = contentBlocks.filter(isToolUseBlock);
@@ -21858,30 +22668,33 @@ function convertMessageToOpenAIFormat(msg) {
 * Convert an array of IMessages from B4M standard format to OpenAI-compatible format.
 * Returns OpenAIFormattedMessage[] - callers targeting OpenAI SDK types should cast at the boundary.
 */
-function convertMessagesToOpenAIFormat(messages) {
-	return messages.flatMap(convertMessageToOpenAIFormat);
+function convertMessagesToOpenAIFormat(messages, options = {}) {
+	return messages.flatMap((msg) => convertMessageToOpenAIFormat(msg, options));
 }
 /**
-* Moonshot AI's Kimi models, served from their OpenAI-compatible endpoint.
+* DeepSeek's models, served from their own OpenAI-compatible endpoint.
 *
-* Structurally this is xaiBackend's twin - same OpenAI SDK against a different
+* Structurally this is kimiBackend's twin - same OpenAI SDK against a different
 * baseURL, same recursive tool loop, same multi-turn token accumulators - and the
-* two must stay in sync on that machinery. Three things genuinely differ:
+* three OpenAI-compatible backends must stay in sync on that machinery. What
+* genuinely differs here:
 *
-* 1. `max_tokens` is deprecated upstream in favor of `max_completion_tokens`.
-* 2. Structured output is NATIVE (json_schema), not the best-effort prompt
-*    injection xAI needs, so callers get responseFormatMode: 'native'.
-* 3. Reasoning controls are per-model and mutually exclusive; see kimiParams.
+* 1. The base URL carries NO `/v1` segment; the SDK appends the path itself.
+* 2. Thinking is on by default and its sampling restrictions are SILENT no-ops
+*    rather than 400s; see deepseekParams.
+* 3. The prior turn's `reasoning_content` has to be replayed on the assistant
+*    tool-call message whenever the request carries `tools`, which is the
+*    opposite of the usual provider rule. See pushToolMessages.
 *
-* @see https://platform.kimi.ai/docs/api/chat
+* @see https://api-docs.deepseek.com/api/create-chat-completion
 */
-var KimiBackend = class {
-	_baseUrl = "https://api.moonshot.ai/v1";
+var DeepSeekBackend = class {
+	_baseUrl = "https://api.deepseek.com";
 	_api;
 	logger;
 	currentModel = "";
 	constructor(apiKey, logger) {
-		if (!apiKey) throw new Error("Moonshot API key is required");
+		if (!apiKey) throw new Error("DeepSeek API key is required");
 		this._api = new OpenAI({
 			apiKey,
 			baseURL: this._baseUrl
@@ -21891,117 +22704,35 @@ var KimiBackend = class {
 	/**
 	* Seed listing. Post-registry this is the fallback tier, not the source of
 	* truth: the catalog overlays context window, limits, lifecycle and price on
-	* top of these rows, and discovery keeps them current without a deploy. What
-	* cannot come from a feed - and so has to live here - is the reasoning and
-	* dispatch shape each id needs.
+	* top of these rows. DeepSeek's own GET /models returns id/object/owned_by and
+	* nothing else, so everything below has to live here.
+	*
+	* Prices are the PEAK rates. Off-peak (outside 01:00-04:00 and 06:00-10:00 UTC,
+	* Mon-Fri) is exactly half, and ModelInfo.pricing is keyed by context tier with
+	* no time dimension to express that in - so the rate that never under-bills is
+	* the one recorded.
 	*/
 	async getModelInfo() {
-		return [
-			{
-				id: ChatModels.KIMI_K3,
-				type: "text",
-				name: "Kimi K3",
-				backend: ModelBackend.Kimi,
-				contextWindow: 1048576,
-				max_tokens: 131072,
-				can_stream: true,
-				pricing: { 1048576: {
-					input: 3 / 1e6,
-					output: 15 / 1e6,
-					cache_read: .3 / 1e6
-				} },
-				can_think: true,
-				supportsVision: true,
-				supportsTools: true,
-				supportsImageVariation: false,
-				releaseDate: "2026-07-16",
-				description: "Moonshot's Kimi K3 flagship. 1M context with native vision, tool use, and selectable reasoning effort (low/high/max). Always reasons - effort sets depth, not whether."
-			},
-			{
-				id: ChatModels.KIMI_K2_7_CODE,
-				type: "text",
-				name: "Kimi K2.7 Code",
-				backend: ModelBackend.Kimi,
-				contextWindow: 262144,
-				max_tokens: 131072,
-				can_stream: true,
-				pricing: { 262144: {
-					input: .95 / 1e6,
-					output: 4 / 1e6,
-					cache_read: .19 / 1e6
-				} },
-				can_think: true,
-				supportsVision: true,
-				supportsTools: true,
-				supportsImageVariation: false,
-				releaseDate: "2026-06-12",
-				trainingCutoff: "2025-01-01",
-				description: "Moonshot's coding-focused Kimi, tuned for long-horizon repository work with less overthinking. Thinking cannot be disabled."
-			},
-			{
-				id: ChatModels.KIMI_K2_7_CODE_HIGHSPEED,
-				type: "text",
-				name: "Kimi K2.7 Code (High Speed)",
-				backend: ModelBackend.Kimi,
-				contextWindow: 262144,
-				max_tokens: 131072,
-				can_stream: true,
-				pricing: { 262144: {
-					input: 1.9 / 1e6,
-					output: 8 / 1e6,
-					cache_read: .38 / 1e6
-				} },
-				can_think: true,
-				supportsVision: true,
-				supportsTools: true,
-				supportsImageVariation: false,
-				releaseDate: "2026-06-12",
-				trainingCutoff: "2025-01-01",
-				description: "Kimi K2.7 Code served at 180-260 tokens/s for latency-sensitive work. Identical capabilities to K2.7 Code at twice the price."
-			},
-			{
-				id: ChatModels.KIMI_K2_6,
-				type: "text",
-				name: "Kimi K2.6",
-				backend: ModelBackend.Kimi,
-				contextWindow: 262144,
-				max_tokens: 131072,
-				can_stream: true,
-				pricing: { 262144: {
-					input: .95 / 1e6,
-					output: 4 / 1e6,
-					cache_read: .16 / 1e6
-				} },
-				can_think: true,
-				supportsVision: true,
-				supportsTools: true,
-				supportsImageVariation: false,
-				releaseDate: "2026-04-21",
-				trainingCutoff: "2025-01-01",
-				description: "Moonshot's multimodal workhorse for agent loops, coding, and visual context. Thinking can be turned off on this one, unlike the K2.7 code models."
-			},
-			{
-				id: ChatModels.KIMI_K2_5,
-				type: "text",
-				name: "Kimi K2.5",
-				backend: ModelBackend.Kimi,
-				contextWindow: 262144,
-				max_tokens: 131072,
-				can_stream: true,
-				pricing: { 262144: {
-					input: .6 / 1e6,
-					output: 3 / 1e6,
-					cache_read: .1 / 1e6
-				} },
-				can_think: true,
-				supportsVision: true,
-				supportsTools: true,
-				supportsImageVariation: false,
-				releaseDate: "2026-01-01",
-				trainingCutoff: "2025-01-01",
-				description: "The previous-generation Kimi, still the cheapest of the family. Superseded by K2.6 on quality at a modest price increase."
-			}
-		];
+		return [{
+			id: ChatModels.DEEPSEEK_FLASH,
+			type: "text",
+			name: "DeepSeek Flash",
+			backend: ModelBackend.DeepSeek,
+			contextWindow: 1e6,
+			max_tokens: 393216,
+			can_stream: true,
+			pricing: { 1e6: {
+				input: .3 / 1e6,
+				output: 1.2 / 1e6,
+				cache_read: .006 / 1e6
+			} },
+			can_think: true,
+			supportsVision: true,
+			supportsTools: true,
+			supportsImageVariation: false,
+			releaseDate: "2026-08-13",
+			description: "DeepSeek's V4.1-Flash. 1M context with native vision, tool use, and selectable reasoning effort (low/high/max). Always reasons unless thinking is turned off."
+		}];
 	}
 	async complete(model, messages, options, callback, toolsUsed = []) {
 		this.currentModel = model;
@@ -22011,7 +22742,7 @@ var KimiBackend = class {
 		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.`);
+			this.logger.warn(`Max tool calls limit (${maxToolCalls}) reached. Disabling tools to prevent infinite loops.`);
 			await this.complete(model, stripToolDependentMessages(messages), {
 				...options,
 				tools: void 0,
@@ -22021,53 +22752,740 @@ var KimiBackend = class {
 		}
 		const rawTools = options.tools;
 		options.tools = Array.isArray(rawTools) ? rawTools : rawTools ? [rawTools] : void 0;
-		const useStreaming = options.stream && (!options.n || options.n === 1);
+		if ((options.n ?? 1) > 1) this.logger.warn(`DeepSeek has no 'n' parameter; ignoring the request for ${options.n} choices.`);
+		const useStreaming = Boolean(options.stream);
+		const reasoning = {
+			thinking: options.thinking,
+			reasoningEffort: options.reasoningEffort
+		};
+		const messagesWithFormat = injectJsonSchemaInstruction(messages, options.responseFormat);
+		const bestEffortFormat = isBestEffortJsonSchema(options.responseFormat);
 		const parameters = {
 			model,
-			messages: this.formatMessages(messages)
+			messages: this.formatMessages(messagesWithFormat)
 		};
 		Object.assign(parameters, {
-			...kimiSamplingParams(model, {
+			...deepseekSamplingParams(model, {
 				temperature: options.temperature,
 				topP: options.topP,
 				presencePenalty: options.presencePenalty,
-				frequencyPenalty: options.frequencyPenalty,
-				n: options.n
-			}),
-			...kimiReasoningParams(model, {
-				thinking: options.thinking,
-				reasoningEffort: options.reasoningEffort
-			}),
-			stop: options.stop,
+				frequencyPenalty: options.frequencyPenalty
+			}, reasoning),
+			...deepseekReasoningParams(model, reasoning),
+			stop: deepseekStopSequences(options.stop),
 			stream: useStreaming,
-			max_completion_tokens: options.maxTokens,
+			max_tokens: options.maxTokens,
 			...useStreaming && { stream_options: { include_usage: true } }
 		});
 		if (options.tools?.length) {
 			parameters.tools = this.formatTools(options.tools);
-			const choice = kimiToolChoice(model, options.tool_choice);
-			if (choice !== void 0) parameters.tool_choice = choice;
+			if (options.tool_choice !== void 0) parameters.tool_choice = options.tool_choice;
 		}
-		if (options.responseFormat?.type === "json_schema") {
-			const rf = options.responseFormat;
-			parameters.response_format = {
-				type: "json_schema",
-				json_schema: {
-					name: rf.json_schema.name,
-					...rf.json_schema.description ? { description: rf.json_schema.description } : {},
-					schema: rf.json_schema.schema,
-					...rf.json_schema.strict !== void 0 ? { strict: rf.json_schema.strict } : { strict: true }
-				}
-			};
-		} else if (options.responseFormat?.type === "text") parameters.response_format = { type: "text" };
-		const nativeFormat = options.responseFormat?.type === "json_schema";
+		if (options.responseFormat?.type === "json_schema") parameters.response_format = { type: "json_object" };
+		else if (options.responseFormat?.type === "text") parameters.response_format = { type: "text" };
 		const cacheStrategy = options.cacheStrategy;
 		const response = await this._api.chat.completions.create(parameters, { signal: options.abortSignal });
 		let inputTokens = 0;
 		let outputTokens = 0;
 		if (!(response instanceof Stream)) {
 			const streamedText = [];
-			if (!response.choices || response.choices.length === 0) throw new Error("No choices returned from the Moonshot API");
+			if (!response.choices || response.choices.length === 0) throw new Error("No choices returned from the DeepSeek API");
+			const turnCacheReadTokens = cachedTokensFromUsage(response.usage);
+			for (const c of response.choices) {
+				if (!c.message) continue;
+				const reasoningContent = c.message.reasoning_content;
+				if (c.message.tool_calls && c.message.tool_calls.length > 0) {
+					for (const toolCall of c.message.tool_calls) {
+						if (toolCall.type !== "function") continue;
+						if (toolCall.function.arguments) toolsUsed.push({
+							name: toolCall.function.name,
+							arguments: toolCall.function.arguments,
+							id: toolCall.id
+						});
+					}
+					if (options.executeTools !== false) {
+						const resolvedTools = [];
+						for (const toolCall of c.message.tool_calls) {
+							if (toolCall.type !== "function" || !toolCall.function.arguments) continue;
+							const toolFn = options.tools?.find((t) => t.toolSchema.name === toolCall.function.name)?.toolFn;
+							if (!toolFn) continue;
+							try {
+								const parsedParams = JSON.parse(toolCall.function.arguments);
+								resolvedTools.push({
+									id: toolCall.id,
+									name: toolCall.function.name,
+									parameters: toolCall.function.arguments,
+									parsedParams,
+									toolFn
+								});
+							} catch {
+								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;
+						this.logger.debug("[Tool Execution] Executing tools (DeepSeek non-streaming)", {
+							mode: parallelEnabled && resolvedTools.length > 1 ? "parallel" : "sequential",
+							toolNames: resolvedTools.map((t) => t.name)
+						});
+						const outcomes = (await executeToolsBatch(resolvedTools.map(({ id, name, parameters: toolParams, parsedParams, toolFn }) => async () => {
+							return {
+								id,
+								name,
+								parameters: toolParams,
+								result: await toolFn(parsedParams)
+							};
+						}), {
+							parallel: parallelEnabled,
+							maxConcurrency: options.maxParallelTools
+						})).map((outcome, i) => outcome.ok ? {
+							ok: true,
+							...outcome.result
+						} : {
+							ok: false,
+							id: resolvedTools[i].id,
+							name: resolvedTools[i].name,
+							parameters: resolvedTools[i].parameters,
+							error: outcome.error
+						});
+						let turnReasoning = reasoningContent;
+						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, turnReasoning ? [turnReasoning] : void 0);
+							} 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
+								}, observation, turnReasoning ? [turnReasoning] : void 0);
+							}
+							turnReasoning = void 0;
+						}
+						await this.complete(model, messages, {
+							...options,
+							_internal: {
+								...options._internal,
+								toolCallCount: toolCallCount + 1,
+								accumInputTokens: accumInputTokens + (response.usage?.prompt_tokens || 0),
+								accumOutputTokens: accumOutputTokens + (response.usage?.completion_tokens || 0),
+								accumCacheReadTokens: accumCacheReadTokens + turnCacheReadTokens
+							}
+						}, callback, toolsUsed);
+						return;
+					} else {
+						this.logger.debug(`[Tool Execution] executeTools=false, passing tool calls to callback`);
+						await callback([null], {
+							...splitCacheInclusiveInput(accumInputTokens + (response.usage?.prompt_tokens || 0), accumCacheReadTokens + turnCacheReadTokens),
+							outputTokens: accumOutputTokens + (response.usage?.completion_tokens || 0),
+							toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
+						});
+						return;
+					}
+				} else {
+					const content = c.message.content || "";
+					streamedText[c.index] = reasoningContent ? `<think>${reasoningContent}</think>${content}` : content;
+				}
+			}
+			if (streamedText.every((text) => !text) && toolsUsed.length === 0) {
+				const finish = response.choices[0]?.finish_reason;
+				throw new Error(finish === "length" ? `DeepSeek returned no content for ${model}: the output budget was exhausted before any answer was produced (finish_reason: length). Raise maxTokens or lower the reasoning effort.` : `DeepSeek returned no content for ${model} (finish_reason: ${finish ?? "unknown"}).`);
+			}
+			let cacheStats;
+			if (cacheStrategy?.enableCaching && response.usage) {
+				cacheStats = getCachingAdapter(ModelBackend.DeepSeek).extractCacheStats(response, model);
+				if (cacheStats) logCacheStats(this.logger, cacheStats, { streaming: false });
+			}
+			const finishReason = normalizeOpenAIFinishReason(response.choices[0]?.finish_reason);
+			const totalCacheReadTokens = accumCacheReadTokens + turnCacheReadTokens;
+			await callback(streamedText, {
+				...splitCacheInclusiveInput(accumInputTokens + (response.usage?.prompt_tokens || 0), totalCacheReadTokens),
+				outputTokens: accumOutputTokens + (response.usage?.completion_tokens || 0),
+				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
+				cacheStats,
+				...bestEffortFormat ? { responseFormatMode: "best-effort" } : {},
+				...finishReason ? { stopReason: finishReason } : {}
+			});
+			return;
+		}
+		const func = [];
+		let isInThinkingBlock = false;
+		let streamedReasoning = "";
+		let cachedTokensFromStream = 0;
+		let streamFinishReason;
+		let sawAnyText = false;
+		for await (const chunk of response) {
+			const streamedText = [];
+			if (chunk.usage) {
+				inputTokens = Math.max(inputTokens, chunk.usage?.prompt_tokens || 0);
+				outputTokens += chunk.usage?.completion_tokens || 0;
+				const chunkCached = cachedTokensFromUsage(chunk.usage);
+				if (chunkCached > 0) cachedTokensFromStream = chunkCached;
+			}
+			chunk?.choices.forEach((c) => {
+				if (c.finish_reason) streamFinishReason = c.finish_reason;
+				const deltaReasoning = c.delta.reasoning_content;
+				if (deltaReasoning) {
+					streamedReasoning += deltaReasoning;
+					if (!isInThinkingBlock) {
+						isInThinkingBlock = true;
+						streamedText[c.index] = "<think>" + deltaReasoning;
+					} else streamedText[c.index] = deltaReasoning;
+					if (!c.delta.content) return;
+				}
+				if (isInThinkingBlock && c.delta.content) {
+					isInThinkingBlock = false;
+					streamedText[c.index] = (streamedText[c.index] ?? "") + "</think>" + c.delta.content;
+					return;
+				}
+				c.delta.tool_calls?.map((tool) => {
+					func[tool.index] ||= {};
+					func[tool.index].name ||= tool.function?.name;
+					func[tool.index].id ||= tool.id;
+					func[tool.index].parameters ??= "";
+					func[tool.index].parameters += tool.function?.arguments || "";
+				});
+				if (func.length > 0) return;
+				streamedText[c.index] = c.delta.content || "";
+			});
+			if (streamedText.some((t) => t)) sawAnyText = true;
+			const normalizedFinishReason = normalizeOpenAIFinishReason(streamFinishReason);
+			await callback(streamedText, {
+				...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
+				outputTokens: accumOutputTokens + outputTokens,
+				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
+				...normalizedFinishReason ? { stopReason: normalizedFinishReason } : {}
+			});
+		}
+		if (isInThinkingBlock) {
+			await callback(["</think>"], {
+				...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
+				outputTokens: accumOutputTokens + outputTokens,
+				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
+			});
+			isInThinkingBlock = false;
+		}
+		if (!sawAnyText && func.length === 0 && toolsUsed.length === 0) throw new Error(streamFinishReason === "length" ? `DeepSeek returned no content for ${model}: the output budget was exhausted before any answer was produced (finish_reason: length). Raise maxTokens or lower the reasoning effort.` : `DeepSeek returned no content for ${model} (finish_reason: ${streamFinishReason ?? "unknown"}).`);
+		let cacheStats;
+		if (cacheStrategy?.enableCaching && inputTokens > 0) {
+			cacheStats = getCachingAdapter(ModelBackend.DeepSeek).extractCacheStats({ usage: {
+				prompt_tokens: inputTokens,
+				completion_tokens: outputTokens,
+				prompt_cache_hit_tokens: cachedTokensFromStream
+			} }, model);
+			if (cacheStats) logCacheStats(this.logger, cacheStats, { streaming: true });
+		}
+		if ((cacheStats || bestEffortFormat) && func.length === 0) {
+			const terminalFinishReason = normalizeOpenAIFinishReason(streamFinishReason);
+			await callback([""], {
+				...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
+				outputTokens: accumOutputTokens + outputTokens,
+				toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
+				...cacheStats ? { cacheStats } : {},
+				...bestEffortFormat ? { responseFormatMode: "best-effort" } : {},
+				...terminalFinishReason ? { stopReason: terminalFinishReason } : {}
+			});
+		}
+		if (func.length > 0) {
+			for await (const tool of func) {
+				const { name, parameters: toolParams, id } = tool;
+				if (name) toolsUsed.push({
+					name,
+					arguments: toolParams || "{}",
+					id
+				});
+			}
+			if (options.executeTools !== false) {
+				const resolvedTools = [];
+				for (const tool of func) {
+					const { id, name } = tool;
+					if (!id || !name) continue;
+					const toolParams = tool.parameters || "{}";
+					const toolFn = options.tools?.find((t) => t.toolSchema.name === name)?.toolFn;
+					if (!toolFn) continue;
+					try {
+						const parsedParams = JSON.parse(toolParams);
+						resolvedTools.push({
+							id,
+							name,
+							parameters: toolParams,
+							parsedParams,
+							toolFn
+						});
+					} catch {
+						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;
+				this.logger.debug("[Tool Execution] Executing tools (DeepSeek streaming)", {
+					mode: parallelEnabled && resolvedTools.length > 1 ? "parallel" : "sequential",
+					toolNames: resolvedTools.map((t) => t.name)
+				});
+				const outcomes = (await executeToolsBatch(resolvedTools.map(({ id, name, parameters: toolParams, parsedParams, toolFn }) => async () => {
+					return {
+						id,
+						name,
+						parameters: toolParams,
+						result: await toolFn(parsedParams)
+					};
+				}), {
+					parallel: parallelEnabled,
+					maxConcurrency: options.maxParallelTools
+				})).map((outcome, i) => outcome.ok ? {
+					ok: true,
+					...outcome.result
+				} : {
+					ok: false,
+					id: resolvedTools[i].id,
+					name: resolvedTools[i].name,
+					parameters: resolvedTools[i].parameters,
+					error: outcome.error
+				});
+				let turnReasoning = streamedReasoning || void 0;
+				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, turnReasoning ? [turnReasoning] : void 0);
+					} 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
+						}, observation, turnReasoning ? [turnReasoning] : void 0);
+					}
+					turnReasoning = void 0;
+				}
+				await this.complete(model, messages, {
+					...options,
+					_internal: {
+						...options._internal,
+						toolCallCount: toolCallCount + 1,
+						accumInputTokens: accumInputTokens + inputTokens,
+						accumOutputTokens: accumOutputTokens + outputTokens,
+						accumCacheReadTokens: accumCacheReadTokens + cachedTokensFromStream
+					}
+				}, callback, toolsUsed);
+			} else {
+				this.logger.debug(`[Tool Execution] executeTools=false, passing tool calls to callback`);
+				await callback([null], {
+					...splitCacheInclusiveInput(accumInputTokens + inputTokens, accumCacheReadTokens + cachedTokensFromStream),
+					outputTokens: accumOutputTokens + outputTokens,
+					toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0,
+					...cacheStats ? { cacheStats } : {}
+				});
+			}
+		}
+	}
+	formatMessages(messages) {
+		return convertMessagesToOpenAIFormat(messages, { preserveReasoningContent: true });
+	}
+	formatTools(tools = []) {
+		return tools.map((tool) => ({
+			type: "function",
+			function: tool.toolSchema
+		}));
+	}
+	/**
+	* `thinkingBlocks` carries the turn's `reasoning_content` as a single string
+	* entry. DeepSeek inverts the usual rule: when a request carries `tools`, the
+	* prior turn's monologue MUST be replayed on the assistant tool-call message or
+	* reasoning continuity breaks across the loop. formatMessages opts into the
+	* converter's `preserveReasoningContent` for exactly this path; every other
+	* target strips it, because this array is shared with the fallback hop.
+	*/
+	pushToolMessages(messages, tool, result, thinkingBlocks) {
+		const reasoningContent = typeof thinkingBlocks?.[0] === "string" ? thinkingBlocks[0] : void 0;
+		messages.push({
+			content: null,
+			role: "assistant",
+			...reasoningContent ? { reasoning_content: reasoningContent } : {},
+			tool_calls: [{
+				id: tool.id,
+				type: "function",
+				function: {
+					name: tool.name,
+					arguments: tool.parameters
+				}
+			}]
+		});
+		messages.push({
+			role: "tool",
+			content: JSON.stringify({ result }),
+			tool_call_id: tool.id
+		});
+	}
+	replaceLastToolResultObservation(messages, toolCallId, newObservation) {
+		replaceLastToolResultObservationOpenAI(messages, toolCallId, newObservation);
+	}
+	getLatestToolCallId(messages, toolName) {
+		return getLatestToolCallIdOpenAI(messages, toolName);
+	}
+};
+/**
+* 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().
+*
+* Moonshot is OpenAI-compatible in envelope only. The reasoning controls, the
+* sampling pins, and the max-tokens parameter all differ per model, and sending
+* the wrong one is a 400 rather than a silently ignored field.
+* @see https://platform.kimi.ai/docs/api/chat
+*/
+/** Kimi's own effort vocabulary, which is not OpenAI's and not B4M's. */
+const KIMI_EFFORT_LEVELS = [
+	"low",
+	"high",
+	"max"
+];
+/**
+* Takes `reasoning_effort`. K3 only, and K3 always reasons - there is no way to
+* turn thinking off, so the parameter selects depth, never whether.
+*/
+const EFFORT_MODELS = /* @__PURE__ */ new Set([ChatModels.KIMI_K3]);
+/** Takes the `thinking` object instead of `reasoning_effort`. */
+const THINKING_MODELS = /* @__PURE__ */ new Set([
+	ChatModels.KIMI_K2_7_CODE,
+	ChatModels.KIMI_K2_7_CODE_HIGHSPEED,
+	ChatModels.KIMI_K2_6,
+	ChatModels.KIMI_K2_5
+]);
+/**
+* `thinking.type` accepts only 'enabled' on the K2.7 code models - 'disabled' is
+* rejected. So a caller asking for no thinking gets thinking anyway; the
+* alternative is a 400, and the parameter is omitted rather than fought.
+*/
+const THINKING_ALWAYS_ON = /* @__PURE__ */ new Set([ChatModels.KIMI_K2_7_CODE, ChatModels.KIMI_K2_7_CODE_HIGHSPEED]);
+/**
+* Rejects `tool_choice: 'required'` (auto and none are fine, as is the explicit
+* function form). Downgraded to 'auto' rather than dropped: a caller that asked
+* for a forced tool still wants tools offered.
+*/
+const NO_REQUIRED_TOOL_CHOICE = /* @__PURE__ */ new Set([
+	ChatModels.KIMI_K2_7_CODE,
+	ChatModels.KIMI_K2_7_CODE_HIGHSPEED,
+	ChatModels.KIMI_K2_6
+]);
+/** Every Kimi id this build ships, direct-served. Bedrock-served Kimi is not here. */
+const KIMI_MODELS = /* @__PURE__ */ new Set([
+	ChatModels.KIMI_K3,
+	ChatModels.KIMI_K2_7_CODE,
+	ChatModels.KIMI_K2_7_CODE_HIGHSPEED,
+	ChatModels.KIMI_K2_6,
+	ChatModels.KIMI_K2_5
+]);
+/**
+* B4M's six-level effort onto Kimi's three. 'none' and 'minimal' map to 'low'
+* rather than to omission because K3 cannot be asked not to think - claiming
+* otherwise by dropping the parameter would silently bill max-effort reasoning
+* (Moonshot's default is 'max').
+*/
+function toKimiEffort(effort) {
+	if (!effort) return void 0;
+	switch (effort) {
+		case "none":
+		case "minimal":
+		case "low": return "low";
+		case "medium":
+		case "high": return "high";
+		case "xhigh": return "max";
+		default: return;
+	}
+}
+/**
+* The reasoning parameters for one model, or an empty object when it takes none.
+* Mutually exclusive by construction: no Kimi model accepts both spellings, and
+* sending both is a 400.
+*/
+function kimiReasoningParams(model, input) {
+	if (EFFORT_MODELS.has(model)) {
+		const effort = toKimiEffort(input.reasoningEffort);
+		return effort ? { reasoning_effort: effort } : {};
+	}
+	if (THINKING_MODELS.has(model)) {
+		if (THINKING_ALWAYS_ON.has(model)) return { thinking: { type: "enabled" } };
+		if (input.thinking?.enabled === void 0) return {};
+		return { thinking: { type: input.thinking.enabled ? "enabled" : "disabled" } };
+	}
+	return {};
+}
+/**
+* Sampling parameters for one model. Moonshot pins temperature (1.0) and top_p
+* (0.95) on every current Kimi and documents them as unmodifiable, so they are
+* omitted rather than sent-and-ignored; NO_TEMPERATURE_MODELS is the shared set
+* the catalog's temperatureMode also lands on.
+*
+* The penalties and `n` ride the same gate. Moonshot documents the whole sampling
+* group as fixed on these ids, B4M sends penalties on essentially every turn, and
+* an unmodifiable parameter here is a 400 rather than a silently ignored field -
+* so the conservative reading is the safe one. Only the moonshot-v1 family, which
+* this build does not ship, accepts any of them.
+*/
+function kimiSamplingParams(model, input) {
+	if (NO_TEMPERATURE_MODELS.has(model)) return {};
+	const params = {};
+	if (input.temperature !== void 0) params.temperature = input.temperature;
+	if (input.topP !== void 0) params.top_p = input.topP;
+	if (input.presencePenalty !== void 0) params.presence_penalty = input.presencePenalty;
+	if (input.frequencyPenalty !== void 0) params.frequency_penalty = input.frequencyPenalty;
+	if (input.n !== void 0) params.n = input.n;
+	return params;
+}
+/** `tool_choice`, downgraded to 'auto' on the ids that reject 'required'. */
+function kimiToolChoice(model, choice) {
+	if (choice === void 0) return void 0;
+	if (choice === "required" && NO_REQUIRED_TOOL_CHOICE.has(model)) return "auto";
+	return choice;
+}
+/**
+* Moonshot AI's Kimi models, served from their OpenAI-compatible endpoint.
+*
+* Structurally this is xaiBackend's twin - same OpenAI SDK against a different
+* baseURL, same recursive tool loop, same multi-turn token accumulators - and the
+* two must stay in sync on that machinery. Three things genuinely differ:
+*
+* 1. `max_tokens` is deprecated upstream in favor of `max_completion_tokens`.
+* 2. Structured output is NATIVE (json_schema), not the best-effort prompt
+*    injection xAI needs, so callers get responseFormatMode: 'native'.
+* 3. Reasoning controls are per-model and mutually exclusive; see kimiParams.
+*
+* @see https://platform.kimi.ai/docs/api/chat
+*/
+var KimiBackend = class {
+	_baseUrl = "https://api.moonshot.ai/v1";
+	_api;
+	logger;
+	currentModel = "";
+	constructor(apiKey, logger) {
+		if (!apiKey) throw new Error("Moonshot API key is required");
+		this._api = new OpenAI({
+			apiKey,
+			baseURL: this._baseUrl
+		});
+		this.logger = logger ?? new Logger();
+	}
+	/**
+	* Seed listing. Post-registry this is the fallback tier, not the source of
+	* truth: the catalog overlays context window, limits, lifecycle and price on
+	* top of these rows, and discovery keeps them current without a deploy. What
+	* cannot come from a feed - and so has to live here - is the reasoning and
+	* dispatch shape each id needs.
+	*/
+	async getModelInfo() {
+		return [
+			{
+				id: ChatModels.KIMI_K3,
+				type: "text",
+				name: "Kimi K3",
+				backend: ModelBackend.Kimi,
+				contextWindow: 1048576,
+				max_tokens: 131072,
+				can_stream: true,
+				pricing: { 1048576: {
+					input: 3 / 1e6,
+					output: 15 / 1e6,
+					cache_read: .3 / 1e6
+				} },
+				can_think: true,
+				supportsVision: true,
+				supportsTools: true,
+				supportsImageVariation: false,
+				releaseDate: "2026-07-16",
+				description: "Moonshot's Kimi K3 flagship. 1M context with native vision, tool use, and selectable reasoning effort (low/high/max). Always reasons - effort sets depth, not whether."
+			},
+			{
+				id: ChatModels.KIMI_K2_7_CODE,
+				type: "text",
+				name: "Kimi K2.7 Code",
+				backend: ModelBackend.Kimi,
+				contextWindow: 262144,
+				max_tokens: 131072,
+				can_stream: true,
+				pricing: { 262144: {
+					input: .95 / 1e6,
+					output: 4 / 1e6,
+					cache_read: .19 / 1e6
+				} },
+				can_think: true,
+				supportsVision: true,
+				supportsTools: true,
+				supportsImageVariation: false,
+				releaseDate: "2026-06-12",
+				trainingCutoff: "2025-01-01",
+				description: "Moonshot's coding-focused Kimi, tuned for long-horizon repository work with less overthinking. Thinking cannot be disabled."
+			},
+			{
+				id: ChatModels.KIMI_K2_7_CODE_HIGHSPEED,
+				type: "text",
+				name: "Kimi K2.7 Code (High Speed)",
+				backend: ModelBackend.Kimi,
+				contextWindow: 262144,
+				max_tokens: 131072,
+				can_stream: true,
+				pricing: { 262144: {
+					input: 1.9 / 1e6,
+					output: 8 / 1e6,
+					cache_read: .38 / 1e6
+				} },
+				can_think: true,
+				supportsVision: true,
+				supportsTools: true,
+				supportsImageVariation: false,
+				releaseDate: "2026-06-12",
+				trainingCutoff: "2025-01-01",
+				description: "Kimi K2.7 Code served at 180-260 tokens/s for latency-sensitive work. Identical capabilities to K2.7 Code at twice the price."
+			},
+			{
+				id: ChatModels.KIMI_K2_6,
+				type: "text",
+				name: "Kimi K2.6",
+				backend: ModelBackend.Kimi,
+				contextWindow: 262144,
+				max_tokens: 131072,
+				can_stream: true,
+				pricing: { 262144: {
+					input: .95 / 1e6,
+					output: 4 / 1e6,
+					cache_read: .16 / 1e6
+				} },
+				can_think: true,
+				supportsVision: true,
+				supportsTools: true,
+				supportsImageVariation: false,
+				releaseDate: "2026-04-21",
+				trainingCutoff: "2025-01-01",
+				description: "Moonshot's multimodal workhorse for agent loops, coding, and visual context. Thinking can be turned off on this one, unlike the K2.7 code models."
+			},
+			{
+				id: ChatModels.KIMI_K2_5,
+				type: "text",
+				name: "Kimi K2.5",
+				backend: ModelBackend.Kimi,
+				contextWindow: 262144,
+				max_tokens: 131072,
+				can_stream: true,
+				pricing: { 262144: {
+					input: .6 / 1e6,
+					output: 3 / 1e6,
+					cache_read: .1 / 1e6
+				} },
+				can_think: true,
+				supportsVision: true,
+				supportsTools: true,
+				supportsImageVariation: false,
+				releaseDate: "2026-01-01",
+				trainingCutoff: "2025-01-01",
+				deprecationDate: "2026-08-31",
+				replacedBy: ChatModels.KIMI_K2_6,
+				description: "The previous-generation Kimi, still the cheapest of the family. Superseded by K2.6 on quality at a modest price increase."
+			}
+		];
+	}
+	async complete(model, messages, options, callback, toolsUsed = []) {
+		this.currentModel = model;
+		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.`);
+			await this.complete(model, stripToolDependentMessages(messages), {
+				...options,
+				tools: void 0,
+				_internal: options._internal
+			}, callback, toolsUsed);
+			return;
+		}
+		const rawTools = options.tools;
+		options.tools = Array.isArray(rawTools) ? rawTools : rawTools ? [rawTools] : void 0;
+		const useStreaming = options.stream && (!options.n || options.n === 1);
+		const parameters = {
+			model,
+			messages: this.formatMessages(messages)
+		};
+		Object.assign(parameters, {
+			...kimiSamplingParams(model, {
+				temperature: options.temperature,
+				topP: options.topP,
+				presencePenalty: options.presencePenalty,
+				frequencyPenalty: options.frequencyPenalty,
+				n: options.n
+			}),
+			...kimiReasoningParams(model, {
+				thinking: options.thinking,
+				reasoningEffort: options.reasoningEffort
+			}),
+			stop: options.stop,
+			stream: useStreaming,
+			max_completion_tokens: options.maxTokens,
+			...useStreaming && { stream_options: { include_usage: true } }
+		});
+		if (options.tools?.length) {
+			parameters.tools = this.formatTools(options.tools);
+			const choice = kimiToolChoice(model, options.tool_choice);
+			if (choice !== void 0) parameters.tool_choice = choice;
+		}
+		if (options.responseFormat?.type === "json_schema") {
+			const rf = options.responseFormat;
+			parameters.response_format = {
+				type: "json_schema",
+				json_schema: {
+					name: rf.json_schema.name,
+					...rf.json_schema.description ? { description: rf.json_schema.description } : {},
+					schema: rf.json_schema.schema,
+					...rf.json_schema.strict !== void 0 ? { strict: rf.json_schema.strict } : { strict: true }
+				}
+			};
+		} else if (options.responseFormat?.type === "text") parameters.response_format = { type: "text" };
+		const nativeFormat = options.responseFormat?.type === "json_schema";
+		const cacheStrategy = options.cacheStrategy;
+		const response = await this._api.chat.completions.create(parameters, { signal: options.abortSignal });
+		let inputTokens = 0;
+		let outputTokens = 0;
+		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 = cachedTokensFromUsage(response.usage);
 			for (const c of response.choices) {
 				if (!c.message) continue;
@@ -22217,16 +23635,17 @@ var KimiBackend = class {
 			}
 			chunk?.choices.forEach((c) => {
 				if (c.finish_reason) streamFinishReason = c.finish_reason;
-				if (c.delta.reasoning_content) {
+				const deltaReasoning = c.delta.reasoning_content;
+				if (deltaReasoning) {
 					if (!isInThinkingBlock) {
 						isInThinkingBlock = true;
-						streamedText[c.index] = "<think>" + c.delta.reasoning_content;
-					} else streamedText[c.index] = c.delta.reasoning_content;
-					return;
+						streamedText[c.index] = "<think>" + deltaReasoning;
+					} else streamedText[c.index] = deltaReasoning;
+					if (!c.delta.content) return;
 				}
-				if (isInThinkingBlock && c.delta.content && !c.delta.reasoning_content) {
+				if (isInThinkingBlock && c.delta.content) {
 					isInThinkingBlock = false;
-					streamedText[c.index] = "</think>" + (c.delta.content || "");
+					streamedText[c.index] = (streamedText[c.index] ?? "") + "</think>" + c.delta.content;
 					return;
 				}
 				c.delta.tool_calls?.map((tool) => {
@@ -23137,7 +24556,7 @@ var OpenAIBackend = class {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "OpenAI_Logo.svg",
-				rank: 0,
+				rank: 4,
 				trainingCutoff: "2024-06-01",
 				description: "Reliable for general-purpose text generation and analysis with a standard context window, suitable for a wide range of applications."
 			},
@@ -23158,7 +24577,7 @@ var OpenAIBackend = class {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "OpenAI_Logo.svg",
-				rank: 0,
+				rank: 4,
 				trainingCutoff: "2024-06-01",
 				description: "OpenAI's balanced GPT-4.1 model offering optimal price-performance ratio. Ideal for tasks requiring intelligence and cost efficiency."
 			},
@@ -23179,7 +24598,7 @@ var OpenAIBackend = class {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "OpenAI_Logo.svg",
-				rank: 0,
+				rank: 4,
 				trainingCutoff: "2024-06-01",
 				deprecationDate: "2026-10-23",
 				description: "Designed for high-volume, low-cost processing with rapid response times, ideal for budget-conscious applications."
@@ -23243,7 +24662,7 @@ var OpenAIBackend = class {
 				supportsTools: true,
 				supportsImageVariation: false,
 				logoFile: "OpenAI_Logo.svg",
-				rank: 0,
+				rank: 3,
 				trainingCutoff: "2024-06-01",
 				deprecationDate: "2026-12-11",
 				description: "OpenAI's O3 reasoning model with broad capabilities and up-to-date training data. Superseded by O4 Mini for most use cases.",
@@ -23415,7 +24834,7 @@ var OpenAIBackend = class {
 				supportsImageVariation: false,
 				supportsTools: true,
 				logoFile: "OpenAI_Logo.svg",
-				rank: 1,
+				rank: 2,
 				trainingCutoff: "2026-01-01",
 				releaseDate: "2026-06-23",
 				description: "GPT-5.6 Luna - the fast, cost-efficient GPT-5.6 variant. Great for high-volume workloads that still need solid reasoning, vision, and tool use."
@@ -23481,7 +24900,7 @@ var OpenAIBackend = class {
 				supportsImageVariation: false,
 				supportsTools: true,
 				logoFile: "OpenAI_Logo.svg",
-				rank: 1,
+				rank: 2,
 				trainingCutoff: "2025-08-31",
 				releaseDate: "2026-03-17",
 				description: "Compact GPT-5.4 variant balancing strong performance with lower cost. Great for everyday tasks needing solid reasoning and vision."
@@ -23503,7 +24922,7 @@ var OpenAIBackend = class {
 				supportsImageVariation: false,
 				supportsTools: true,
 				logoFile: "OpenAI_Logo.svg",
-				rank: 1,
+				rank: 2,
 				trainingCutoff: "2025-08-31",
 				releaseDate: "2026-03-17",
 				description: "Ultra-lightweight GPT-5.4 model optimized for speed and cost efficiency. Ideal for high-volume workloads and quick interactions."
@@ -25376,6 +26795,10 @@ function backendForAdapterFamily(family, ctx) {
 			const key = keyOrThrow(apiKeyTable.kimi, "Moonshot");
 			return key ? new KimiBackend(key, logger) : null;
 		}
+		case "deepseek": {
+			const key = keyOrThrow(apiKeyTable.deepseek, "DeepSeek");
+			return key ? new DeepSeekBackend(key, logger) : null;
+		}
 		case "bfl": return new BFLBackend(keyOrThrow(apiKeyTable.bfl, "BFL") ?? "demo-key");
 		case "local-image": {
 			const baseUrl = keyOrThrow(apiKeyTable["local-image"], "Local image");
@@ -25416,6 +26839,7 @@ function buildApiKeyTable(keys) {
 		[ModelBackend.Ollama]: keys.ollama || void 0,
 		[ModelBackend.XAI]: keys.xai || void 0,
 		[ModelBackend.Kimi]: keys.kimi || void 0,
+		[ModelBackend.DeepSeek]: keys.deepseek || void 0,
 		[ModelBackend.VoyageAI]: keys.voyageai || void 0,
 		[ModelBackend.LocalImage]: keys.imageGen || void 0,
 		[ModelBackend.Bedrock]: void 0,
@@ -25442,6 +26866,7 @@ const KEYED_LISTING_BACKENDS = [
 	ModelBackend.BFL,
 	ModelBackend.XAI,
 	ModelBackend.Kimi,
+	ModelBackend.DeepSeek,
 	ModelBackend.LocalImage
 ];
 /**
@@ -25499,6 +26924,7 @@ const DISPATCHABLE_ADAPTER_FAMILIES = [
 	"gemini",
 	"xai",
 	"kimi",
+	"deepseek",
 	"ollama",
 	"bfl",
 	"local-image",
@@ -25576,6 +27002,15 @@ function mergeCatalogWithDrops(seedModels, rows, ctx) {
 	for (const [modelId, bucket] of rowsByModel) {
 		if (seeded.has(modelId)) continue;
 		const { draft } = mergeRows(bucket, null);
+		const status = draft.lifecycle?.status;
+		const lifecycleReason = inactiveLifecycleReason(status);
+		if (lifecycleReason) {
+			dropped.push({
+				modelId,
+				reason: lifecycleReason
+			});
+			continue;
+		}
 		const parsed = asRenderableRecord(draft);
 		if ("reason" in parsed) {
 			dropped.push({
@@ -25692,10 +27127,19 @@ function asRenderableRecord(draft) {
 	if (typeof draft.type !== "string" || !isRenderableModelType(draft.type)) return { reason: `unsupported model type "${String(draft.type)}"` };
 	return { record: draft };
 }
+/**
+* Why a lifecycle status is not invocable, or null when it is "active". Shared
+* between invocabilityBlocker and the catalog-only tier's pre-parse check, so
+* both agree on the exact wording.
+*/
+function inactiveLifecycleReason(status) {
+	if (status !== "active") return `lifecycle status "${status ?? "unset"}" is not invocable`;
+	return null;
+}
 /** Why a catalog-only record is metadata-only, or null when it is invocable. */
 function invocabilityBlocker(record) {
-	const status = record.lifecycle?.status;
-	if (status !== "active") return `lifecycle status "${status ?? "unset"}" is not invocable`;
+	const lifecycleReason = inactiveLifecycleReason(record.lifecycle?.status);
+	if (lifecycleReason) return lifecycleReason;
 	if (!record.adapterFamily) return "no adapterFamily";
 	if (!DISPATCHABLE_ADAPTER_FAMILIES.includes(record.adapterFamily)) return `adapterFamily "${record.adapterFamily}" is not dispatchable by this build`;
 	if (!record.dispatchProfile) return "no dispatchProfile";
@@ -25949,12 +27393,14 @@ const DEPRECATED_MODEL_MAP = {
 	"claude-3-haiku-20240307": "claude-haiku-4-5-20251001",
 	"gpt-5-chat-latest": "gpt-5.5",
 	"gpt-5.1-chat-latest": "gpt-5.5",
+	"gemini-2.5-flash": "gemini-3.1-flash-lite",
 	"grok-3": "grok-4.5",
 	"grok-3-fast": "grok-4.5",
 	"grok-2-1212": "grok-4.5",
 	"grok-2-vision-1212": "grok-4.5",
 	"grok-beta": "grok-4.5",
 	"grok-vision-beta": "grok-4.5",
+	"kimi-k2.5": "kimi-k2.6",
 	"grok-3-mini-fast": "grok-3-mini"
 };
 /**
@@ -26079,6 +27525,58 @@ var UndifferentiatedBedrockBackend = class extends BaseBedrockBackend {
 	}
 };
 /**
+* The prices this build ships in code, keyed by model id.
+*
+* Same provenance as packages/database's modelPrices.seed.json - the adapter
+* `getModelInfo()` literals - reachable without a database, which is what the
+* price planner needs: a model's FIRST discovery-written row has no row in force
+* to carry the rates no feed publishes from, and a tier that reaches
+* getTextModelCost without `cache_read` settles cached reads at
+* input * CACHE_READ_MULTIPLIER. On DeepSeek Flash that default is 0.03/1M
+* against a real 0.006/1M. MUST STAY IN SYNC with collectStaticTextModels in
+* packages/database/src/seeds/generateModelPriceSeed.ts: both lists are "every
+* backend whose getModelInfo() is a static table", and Ollama is absent from
+* both because its listing is a live server call.
+*/
+const STATIC_PRICE_BACKENDS = () => [
+	new OpenAIBackend("price-literal"),
+	new AnthropicBackend("price-literal"),
+	new UndifferentiatedBedrockBackend(),
+	new GeminiBackend("price-literal"),
+	new XAIBackend("price-literal"),
+	new KimiBackend("price-literal"),
+	new DeepSeekBackend("price-literal"),
+	new AWSBackend()
+];
+let cached;
+/**
+* The lowest-threshold tier of each priced text model's adapter literal.
+*
+* Lowest tier on purpose: this is a last-resort carry for rates no feed
+* publishes (cache and audio), and those do not vary by context bracket in any
+* literal we ship, while the threshold keys of a discovered ladder need not
+* match the literal's. Memoized - the tables are static, and the planner runs
+* once per convergence pass.
+*/
+async function adapterPriceTiers() {
+	cached ??= collect();
+	return cached;
+}
+async function collect() {
+	const tables = await Promise.all(STATIC_PRICE_BACKENDS().map((backend) => backend.getModelInfo()));
+	const tiers = /* @__PURE__ */ new Map();
+	for (const model of tables.flat()) {
+		if (model.type !== "text" || model.freeToRun) continue;
+		const tier = lowestTier(model);
+		if (tier) tiers.set(String(model.id), tier);
+	}
+	return tiers;
+}
+function lowestTier(model) {
+	const thresholds = Object.keys(model.pricing).map(Number).filter((threshold) => Number.isFinite(threshold)).sort((a, b) => a - b);
+	return thresholds.length > 0 ? model.pricing[thresholds[0]] : void 0;
+}
+/**
 * The dispatch group for a family whose request builder shapes its payload from
 * the provider's own contract and reads nothing out of the profile (Bedrock,
 * Gemini, xAI, Ollama, and the image/speech backends). Promotion still requires
@@ -26119,6 +27617,15 @@ const KIMI_PROFILE = {
 	maxTokensParam: "max_completion_tokens",
 	toolTransport: "chat"
 };
+/**
+* DeepSeek direct. Its own constant rather than PROVIDER_NATIVE_PROFILE because
+* tools ride Chat Completions rather than a provider-native field, which is what
+* deepseekBackend sends; the token parameter is still `max_tokens`.
+*/
+const DEEPSEEK_PROFILE = {
+	maxTokensParam: "max_tokens",
+	toolTransport: "chat"
+};
 /** Backends whose family is the backend, with a request shape this build fixes. */
 const FAMILY_BY_BACKEND = {
 	[ModelBackend.Anthropic]: "anthropic-messages",
@@ -26160,6 +27667,10 @@ function resolveDispatchForRecord(record) {
 		adapterFamily: "kimi",
 		dispatchProfile: KIMI_PROFILE
 	};
+	if (record.backend === ModelBackend.DeepSeek) return {
+		adapterFamily: "deepseek",
+		dispatchProfile: DEEPSEEK_PROFILE
+	};
 	const adapterFamily = FAMILY_BY_BACKEND[record.backend];
 	return adapterFamily ? {
 		adapterFamily,
@@ -26279,7 +27790,11 @@ var AnthropicBatchService = class AnthropicBatchService {
 					reply: msg.content.filter((b) => b.type === "text").map((b) => b.text).join(""),
 					tokenUsage: {
 						inputTokens: msg.usage?.input_tokens ?? 0,
-						outputTokens: msg.usage?.output_tokens ?? 0
+						outputTokens: msg.usage?.output_tokens ?? 0,
+						cacheReadInputTokens: msg.usage?.cache_read_input_tokens ?? void 0,
+						cacheCreationInputTokens: msg.usage?.cache_creation_input_tokens ?? void 0,
+						cacheWrite5mInputTokens: msg.usage?.cache_creation?.ephemeral_5m_input_tokens ?? void 0,
+						cacheWrite1hInputTokens: msg.usage?.cache_creation?.ephemeral_1h_input_tokens ?? void 0
 					}
 				};
 			}
@@ -26519,6 +28034,10 @@ function getLlmByModel(apiKeyTable, options) {
 			if (apiKeyTable.kimi === "expired") throw new Error("Moonshot API key is expired");
 			backend = apiKeyTable.kimi ? new KimiBackend(apiKeyTable.kimi, logger) : null;
 			break;
+		case "deepseek":
+			if (apiKeyTable.deepseek === "expired") throw new Error("DeepSeek API key is expired");
+			backend = apiKeyTable.deepseek ? new DeepSeekBackend(apiKeyTable.deepseek, logger) : null;
+			break;
 		case "aws":
 			backend = new AWSBackend();
 			break;
@@ -26613,6 +28132,7 @@ const getAvailableModels = async (apiKeys, options = {}) => {
 	const bflKey = resolveListingKey(ModelBackend.BFL, gateCtx);
 	const xaiKey = resolveListingKey(ModelBackend.XAI, gateCtx);
 	const kimiKey = resolveListingKey(ModelBackend.Kimi, gateCtx);
+	const deepseekKey = resolveListingKey(ModelBackend.DeepSeek, gateCtx);
 	const localImageBaseUrl = resolveListingKey(ModelBackend.LocalImage, gateCtx);
 	const backends = {
 		[ModelBackend.OpenAI]: openaiKey ? new OpenAIBackend(openaiKey) : null,
@@ -26623,6 +28143,7 @@ const getAvailableModels = async (apiKeys, options = {}) => {
 		[ModelBackend.BFL]: bflKey ? new BFLBackend(bflKey) : null,
 		[ModelBackend.XAI]: xaiKey ? new XAIBackend(xaiKey) : null,
 		[ModelBackend.Kimi]: kimiKey ? new KimiBackend(kimiKey) : null,
+		[ModelBackend.DeepSeek]: deepseekKey ? new DeepSeekBackend(deepseekKey) : null,
 		[ModelBackend.AWS]: isBackendUsable(ModelBackend.AWS, gateCtx) ? new AWSBackend() : null,
 		[ModelBackend.LocalImage]: localImageBaseUrl ? new LocalImageBackend(localImageBaseUrl, Logger.globalInstance) : null
 	};
@@ -27522,6 +29043,109 @@ async function createSseBackend(input, deps = defaultSseTransportDeps) {
 }
 //#endregion
 //#region ../../b4m-core/mcp/dist/index.mjs
+/**
+* Environment construction for the MCP stdio child process.
+*
+* The child is spawned from a process that also holds platform credentials - provider API keys,
+* database URIs, signing secrets - so what it inherits is a trust decision, not a convenience.
+* Two rules follow:
+*
+* 1. The child environment is built from an allowlist, never spread from `process.env`. The base
+*    layer is the MCP SDK's own `getDefaultEnvironment()`, which the stdio transport merges
+*    underneath whatever we pass (PATH, HOME, SHELL, TERM, USER on POSIX; the equivalent set on
+*    Windows). Everything above that base comes from the table below.
+* 2. A stored variable is provider data, never runtime configuration. The child is a Node
+*    process, so a key like NODE_OPTIONS is applied by the runtime before a single line of
+*    server code loads: `--require /tmp/x.js` would turn a credential field into arbitrary code
+*    execution inside the child. Those keys are refused rather than dropped quietly.
+*
+* MUST STAY IN SYNC with the `process.env` reads under each server directory
+* (`github/config.ts`, `notion/config.ts`, `atlassian/config.ts`, `linkedin/index.ts`). A
+* variable a server reads but this table omits arrives `undefined`, so add it here in the same
+* change. `childEnv.test.ts` pins that both ways.
+*/
+const MCP_SERVER_ENV_KEYS = {
+	[McpServerName.LinkedIn]: ["LINKEDIN_ACCESS_TOKEN", "COMPANY_NAME"],
+	[McpServerName.Github]: ["GITHUB_ACCESS_TOKEN"],
+	[McpServerName.Atlassian]: [
+		"ATLASSIAN_ACCESS_TOKEN",
+		"ATLASSIAN_CLOUD_ID",
+		"ATLASSIAN_SITE_URL"
+	],
+	[McpServerName.Notion]: [
+		"NOTION_ACCESS_TOKEN",
+		"NOTION_WORKSPACE_ID",
+		"NOTION_WRITE_ENABLED",
+		"NOTION_ROOT_PAGE_ID",
+		"NOTION_ACCESS_MODE",
+		"NOTION_ALLOWED_PAGES",
+		"NOTION_EXCLUDED_PAGE_IDS",
+		"NOTION_DEBUG"
+	]
+};
+/**
+* Keys that make the runtime execute caller-chosen code before the server's entry point runs:
+* NODE_OPTIONS can `--require` a file, the loader variables preload a shared object, and
+* ELECTRON_RUN_AS_NODE changes what the binary is. Matching is case-insensitive because Windows
+* environment names are.
+*/
+const CODE_INJECTING_ENV_KEY_PATTERNS = [
+	/^NODE_/i,
+	/^ELECTRON_RUN_AS_NODE$/i,
+	/^LD_/i,
+	/^DYLD_/i
+];
+/**
+* Keys that steer where the child resolves things rather than what it executes: npm_* redirects
+* package resolution, PATH decides which binary a bare command name finds, and the proxy
+* variables redirect outbound traffic.
+*/
+const RESOLUTION_STEERING_ENV_KEY_PATTERNS = [
+	/^npm_/i,
+	/^PATH$/i,
+	/^PATHEXT$/i,
+	/^(HTTP|HTTPS|ALL|NO|FTP)_PROXY$/i,
+	/^GLOBAL_AGENT_/i
+];
+[...CODE_INJECTING_ENV_KEY_PATTERNS, ...RESOLUTION_STEERING_ENV_KEY_PATTERNS];
+const matchesAny = (patterns, key) => {
+	const normalized = key.trim();
+	return patterns.some((pattern) => pattern.test(normalized));
+};
+/** True when `key` would have the runtime load caller-chosen code before the server starts. */
+function isCodeInjectingMcpEnvKey(key) {
+	return matchesAny(CODE_INJECTING_ENV_KEY_PATTERNS, key);
+}
+/**
+* Build the environment for a stdio MCP child.
+*
+* A bundled server gets exactly its declared variables - the allowlist decides, and the denylist
+* above is never consulted.
+*
+* A caller-defined command has no declared contract to check against, so it gets everything
+* except the code-injecting keys. Only the `b4m` CLI config reaches this branch, and that file
+* already lets its owner set `command` and `args` to any binary - so withholding PATH or a proxy
+* variable from them protects nobody while breaking a wrapper script or a corporate proxy, and
+* the warning that says so goes to a stderr the TUI hides. The code-injecting half stays because
+* an env-only `--require` is the one lever that is easy to set by accident.
+*/
+function buildMcpChildEnv({ serverName, envVariables, hasCustomCommand = false }) {
+	const declaredKeys = hasCustomCommand ? void 0 : MCP_SERVER_ENV_KEYS[serverName];
+	const isAllowed = declaredKeys ? (key) => declaredKeys.includes(key) : (key) => !isCodeInjectingMcpEnvKey(key);
+	const env = {};
+	const droppedKeys = [];
+	for (const { key, value } of envVariables) {
+		if (!isAllowed(key)) {
+			droppedKeys.push(key);
+			continue;
+		}
+		env[key] = value;
+	}
+	return {
+		env,
+		droppedKeys
+	};
+}
 var MCPClient = class {
 	mcp;
 	transport = null;
@@ -27565,14 +29189,11 @@ var MCPClient = class {
 				}));
 				return;
 			}
-			const envVarsObject = this.envVariables.reduce((acc, env) => ({
-				...acc,
-				[env.key]: env.value
-			}), {});
 			let command;
 			let args;
-			if (this.customCommand && this.customCommand.trim() !== "") {
-				command = this.customCommand;
+			const customCommand = this.customCommand?.trim() ? this.customCommand : void 0;
+			if (customCommand) {
+				command = customCommand;
 				args = this.customArgs ?? [];
 			} else {
 				const moduleDir = path.dirname(fileURLToPath(import.meta.url));
@@ -27589,13 +29210,16 @@ var MCPClient = class {
 				console.log(`[MCP] Using server: ${this.serverName} at ${serverScriptPath}`);
 			}
 			const stderrMode = this.suppressStderr ? "ignore" : this.onStderrLine ? "pipe" : void 0;
+			const { env, droppedKeys } = buildMcpChildEnv({
+				serverName: this.serverName,
+				envVariables: this.envVariables,
+				hasCustomCommand: Boolean(customCommand)
+			});
+			if (droppedKeys.length > 0) console.warn(`[MCP] Withheld ${droppedKeys.length} undeclared env variable(s) from ${this.serverName}: ${droppedKeys.join(", ")}`);
 			const transportConfig = {
 				command,
 				args,
-				env: {
-					...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0)),
-					...envVarsObject
-				},
+				env,
 				...stderrMode && { stderr: stderrMode }
 			};
 			const stdioTransport = new StdioClientTransport(transportConfig);
@@ -28023,7 +29647,7 @@ const MODEL_ALIASES = {
 	"o4-mini": ChatModels.O4_MINI,
 	gemini: ChatModels.GEMINI_2_5_PRO,
 	"gemini-pro": ChatModels.GEMINI_2_5_PRO,
-	"gemini-flash": ChatModels.GEMINI_2_5_FLASH,
+	"gemini-flash": ChatModels.GEMINI_3_5_FLASH,
 	"gemini-flash-lite": ChatModels.GEMINI_2_5_FLASH_LITE,
 	"gemini-3": ChatModels.GEMINI_3_PRO_PREVIEW,
 	"gemini-3-pro": ChatModels.GEMINI_3_PRO_PREVIEW,
@@ -28042,7 +29666,7 @@ const MODEL_ALIASES = {
 	"grok-3-mini-fast": ChatModels.GROK_3_MINI_FAST,
 	"grok-2": ChatModels.GROK_2,
 	"grok-2-vision": ChatModels.GROK_2_VISION,
-	deepseek: ChatModels.DEEPSEEK_R1,
+	deepseek: ChatModels.DEEPSEEK_FLASH,
 	"deepseek-r1": ChatModels.DEEPSEEK_R1,
 	llama: ChatModels.LLAMA3_LOCAL,
 	llama3: ChatModels.LLAMA3_LOCAL,
@@ -28458,7 +30082,7 @@ function buildFilenameMarkerRegex(markers) {
 * of the best-effort DB pre-filter. Fail-closed by design.
 */
 function isRetrievalExcluded(file, opts) {
-	const stalledByConvergence = isConvergencePausedNote(file.notes) || isChunkRebuildPending(file.chunkRebuildRequestedAt);
+	const stalledByConvergence = isChunkStalledFile(file) || isChunkRebuildPending(file.chunkRebuildRequestedAt);
 	if (opts.vectorizedOnly && !file.vectorized && !stalledByConvergence) return true;
 	const re = buildFilenameMarkerRegex(opts.excludeFilenameMarkers);
 	return !!re && re.test((file.fileName ?? "").toLowerCase());
@@ -28891,8 +30515,11 @@ function effectiveContextWindow(modelInfo) {
 * budget below - and they must not drift apart.
 *
 * The static catalog tables are held to the positive-budget property by
-* modelCatalogInputBudget.test.ts, and a discovered claim that would break it for a TEXT row is
-* refused in modelDiscoveryService/catalogWrite.
+* modelCatalogInputBudget.test.ts. A discovered claim is guarded in two places, one per direction:
+* modelDiscoveryService/catalogWrite refuses a TEXT row whose output cap starves its own window,
+* and the docs parsers refuse a window or an output cap past MAX_PLAUSIBLE_TOKENS
+* (modelDiscoveryService/sources/openaiDocs.ts) - an overstated window is not a non-positive
+* budget, so catalogWrite would never see it, and no aggregator may correct a provider's figure.
 *
 * The buffer figure is imported rather than redeclared here: common owns it, and two copies of the
 * same number is the drift that made it a shared export in the first place.
@@ -29042,6 +30669,18 @@ function attachedContentBudgetsAgree(maxSafeInputTokens, systemPromptReserve) {
 var AdminSettingsCache = class AdminSettingsCache {
 	cache = /* @__PURE__ */ new Map();
 	individualCache = /* @__PURE__ */ new Map();
+	/**
+	* Every call through this field is optional-chained (`this.logger.debug?.()`).
+	*
+	* A cache must not throw because it could not log, and this one is exposed to that: it is a
+	* process-wide singleton created with whichever logger happens to reach `getSettingsCache` first.
+	* What each caller then does with a throw varies, and it is mostly NOT a degrade-to-defaults
+	* guard: `getSettingsByNames` has none at all, the scoped resolver guards one layer out in
+	* `resolveAll`, and `resolveSpendLevers` deliberately rethrows to halt spend. So a logger missing
+	* a quieter level could surface as a silent wrong VALUE, as an unhandled rejection, or as a hard
+	* fail-closed, depending on who asked. `ScopedSettingsCache` is built by the same factory pair
+	* and still has one unguarded call - the same hazard, not a solved one.
+	*/
 	logger;
 	cleanupInterval = null;
 	maxCacheSize = 1e3;
@@ -29057,13 +30696,13 @@ var AdminSettingsCache = class AdminSettingsCache {
 	*/
 	startCleanupTimer() {
 		if (process.env.NODE_ENV !== "production" || process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME) {
-			this.logger.debug("Skipping cleanup timer in serverless environment");
+			this.logger.debug?.("Skipping cleanup timer in serverless environment");
 			return;
 		}
 		this.cleanupInterval = setInterval(() => {
 			this.performCleanup();
 		}, AdminSettingsCache.CLEANUP_INTERVAL);
-		this.logger.debug("Started cache cleanup timer");
+		this.logger.debug?.("Started cache cleanup timer");
 	}
 	/**
 	* Stop cleanup timer (for graceful shutdown)
@@ -29072,7 +30711,7 @@ var AdminSettingsCache = class AdminSettingsCache {
 		if (this.cleanupInterval) {
 			clearInterval(this.cleanupInterval);
 			this.cleanupInterval = null;
-			this.logger.debug("Stopped cache cleanup timer");
+			this.logger.debug?.("Stopped cache cleanup timer");
 		}
 	}
 	/**
@@ -29097,9 +30736,9 @@ var AdminSettingsCache = class AdminSettingsCache {
 				this.individualCache.delete(entries[i][0]);
 				removedCount++;
 			}
-			this.logger.warn(`Emergency cache cleanup: removed ${toRemove} entries due to size limit`);
+			this.logger.warn?.(`Emergency cache cleanup: removed ${toRemove} entries due to size limit`);
 		}
-		if (removedCount > 0) this.logger.debug(`Cache cleanup removed ${removedCount} expired entries (${beforeSize} → ${this.cache.size + this.individualCache.size})`);
+		if (removedCount > 0) this.logger.debug?.(`Cache cleanup removed ${removedCount} expired entries (${beforeSize} → ${this.cache.size + this.individualCache.size})`);
 	}
 	/**
 	* Get TTL based on environment
@@ -29120,18 +30759,18 @@ var AdminSettingsCache = class AdminSettingsCache {
 		const cacheKey = "all_settings";
 		const cached = this.cache.get(cacheKey);
 		if (cached && this.isValid(cached.timestamp, cached.ttl)) {
-			this.logger.debug("📦 Admin settings cache HIT");
+			this.logger.debug?.("📦 Admin settings cache HIT");
 			return cached.data;
 		}
 		if (cached) this.cache.delete(cacheKey);
-		this.logger.debug("🔍 Admin settings cache MISS - fetching from database");
+		this.logger.debug?.("🔍 Admin settings cache MISS - fetching from database");
 		const fetchStart = Date.now();
 		const settingsMap = (await db.adminSettings.findAll()).reduce((out, s) => {
 			out[s.settingName] = s.settingValue;
 			return out;
 		}, {});
 		const fetchTime = Date.now() - fetchStart;
-		this.logger.info(`📦 Cached ${Object.keys(settingsMap).length} admin settings in ${fetchTime}ms`);
+		this.logger.info?.(`📦 Cached ${Object.keys(settingsMap).length} admin settings in ${fetchTime}ms`);
 		const ttl = this.getTTL();
 		this.cache.set(cacheKey, {
 			data: settingsMap,
@@ -29153,15 +30792,15 @@ var AdminSettingsCache = class AdminSettingsCache {
 	async getSettingByName(settingName, db) {
 		const cached = this.individualCache.get(settingName);
 		if (cached && this.isValid(cached.timestamp, cached.ttl)) {
-			this.logger.debug(`📦 Individual setting '${settingName}' cache HIT`);
+			this.logger.debug?.(`📦 Individual setting '${settingName}' cache HIT`);
 			return cached.value;
 		}
 		if (cached) this.individualCache.delete(settingName);
-		this.logger.debug(`🔍 Individual setting '${settingName}' cache MISS - fetching from database`);
+		this.logger.debug?.(`🔍 Individual setting '${settingName}' cache MISS - fetching from database`);
 		const fetchStart = Date.now();
 		const value = (await db.adminSettings.findBySettingName(settingName))?.settingValue ?? null;
 		const fetchTime = Date.now() - fetchStart;
-		this.logger.debug(`📦 Cached individual setting '${settingName}' in ${fetchTime}ms`);
+		this.logger.debug?.(`📦 Cached individual setting '${settingName}' in ${fetchTime}ms`);
 		this.individualCache.set(settingName, {
 			value,
 			timestamp: Date.now(),
@@ -29185,11 +30824,11 @@ var AdminSettingsCache = class AdminSettingsCache {
 			}
 		}
 		if (uncachedSettings.length > 0) {
-			this.logger.debug(`🔍 Batch fetching ${uncachedSettings.length} uncached settings: ${uncachedSettings.join(", ")}`);
+			this.logger.debug?.(`🔍 Batch fetching ${uncachedSettings.length} uncached settings: ${uncachedSettings.join(", ")}`);
 			const fetchStart = Date.now();
 			const settings = await db.adminSettings.findBySettingNames(uncachedSettings);
 			const fetchTime = Date.now() - fetchStart;
-			this.logger.debug(`📦 Batch fetched ${settings.length} settings in ${fetchTime}ms`);
+			this.logger.debug?.(`📦 Batch fetched ${settings.length} settings in ${fetchTime}ms`);
 			const ttl = this.getTTL();
 			settings.forEach((setting) => {
 				result[setting.settingName] = setting.settingValue;
@@ -29207,7 +30846,7 @@ var AdminSettingsCache = class AdminSettingsCache {
 				});
 			});
 		}
-		this.logger.debug(`📦 Returned ${Object.keys(result).length} settings (${settingNames.length - uncachedSettings.length} from cache, ${uncachedSettings.length} from DB)`);
+		this.logger.debug?.(`📦 Returned ${Object.keys(result).length} settings (${settingNames.length - uncachedSettings.length} from cache, ${uncachedSettings.length} from DB)`);
 		return result;
 	}
 	/**
@@ -29216,7 +30855,7 @@ var AdminSettingsCache = class AdminSettingsCache {
 	invalidateSetting(settingName) {
 		this.individualCache.delete(settingName);
 		this.cache.delete("all_settings");
-		this.logger.info(`🗑️ Invalidated cache for setting: ${settingName}`);
+		this.logger.info?.(`🗑️ Invalidated cache for setting: ${settingName}`);
 	}
 	/**
 	* Invalidate all cached admin settings
@@ -29224,7 +30863,7 @@ var AdminSettingsCache = class AdminSettingsCache {
 	invalidateAll() {
 		this.cache.clear();
 		this.individualCache.clear();
-		this.logger.info("🗑️ Invalidated all admin settings cache");
+		this.logger.info?.("🗑️ Invalidated all admin settings cache");
 	}
 	/**
 	* Get cache statistics for monitoring
@@ -29257,16 +30896,16 @@ var AdminSettingsCache = class AdminSettingsCache {
 	* Warm up the cache by fetching all settings
 	*/
 	async warmUp(db) {
-		this.logger.info("🔥 Warming up admin settings cache...");
+		this.logger.info?.("🔥 Warming up admin settings cache...");
 		await this.getSettingsMap(db);
-		this.logger.info("✅ Admin settings cache warmed up");
+		this.logger.info?.("✅ Admin settings cache warmed up");
 	}
 	/**
 	* Graceful shutdown - cleanup timers
 	*/
 	shutdown() {
 		this.stopCleanupTimer();
-		this.logger.info("🛑 Admin settings cache shutdown complete");
+		this.logger.info?.("🛑 Admin settings cache shutdown complete");
 	}
 };
 /** Address of one cached override, shared by the cache and its callers so lookups are consistent. */
@@ -29615,6 +31254,17 @@ const getFileContent = async (fabFile, { storage, logger }) => {
 	}
 	return content;
 };
+/**
+* Content hash for per-lake FabFile dedup (`findByContentHashesInDataLake`). Shared by every
+* ingest path that needs to hash bytes before creating a FabFile - the Slack attachment path
+* (raw downloaded buffer) and the URL/link path (`fetchAndParseURL`'s extracted `textContent`) -
+* so at least the HASHING ITSELF cannot drift between two copies of the same algorithm.
+*
+* This does NOT make `contentHash` one hash domain: the two callers feed it different inputs
+* (raw bytes vs. extracted text), so the same document added once as an attachment and once as a
+* link produces two different hashes and is not caught as a duplicate by this field.
+*/
+const computeContentHash = (content) => createHash$1("sha256").update(content).digest("hex");
 /** The next 1-based version number given the existing (possibly absent) version history. */
 const nextVersionNumber = (versions) => {
 	if (!versions || versions.length === 0) return 1;
@@ -29825,19 +31475,6 @@ const EDITABLE_IMAGE_KEY_RE = /\.(jpe?g|png|webp|gif)$/i;
 const PREVIEW_CHUNK = 700;
 const CHARS_PER_TOKEN = 3.5;
 /**
-* Chunks per attached file that cosine retrieval feeds to the model. Three starved small embedders: a
-* chunk is the embedding model's context window less a 20% buffer (see SmartChunker), so three chunks
-* is roughly 69k chars on an 8192-token embedder but only 4.3k on a 512-token one, which answers a
-* question about a 200-row table from 43 rows without saying so.
-*
-* 10 is borrowed from rankChunksForFiles' topK default, but note the two caps differ in shape: that
-* one is global across every file in the search, this one is PER FILE, so a multi-file attachment can
-* yield more chunks here. What bounds the payload is the per-file character budget applied to these
-* results (maxChars in processFabFilesServer), not this count - and that budget now derives from the
-* model's input window rather than its output limit; see attachedContentExtractionBudget.
-*/
-const COSINE_SEARCH_TOP_K = 10;
-/**
 * How much of one attached file the cosine scan will read, and in what size pages.
 *
 * Module constants rather than admin settings: unlike a data lake, an attachment is one file the
@@ -30249,14 +31886,28 @@ async function fetchAgentConversationHistory(session, questCount, { db }) {
 		return acc;
 	}, new Array());
 }
-async function fetchAndConvertFabFiles(fabFileIds, { scope }, { db, storage }) {
-	const fabFiles = await db.fabfiles.getAccessibleFiles(fabFileIds, scope);
-	return await Promise.all(fabFiles.map(async (file) => {
+/**
+* Resolves attachment ids to documents, and reports the ones it could NOT resolve. The missing set
+* is the point: `getAccessibleFiles` applies a permission scope and simply omits what it rejects, so
+* an id dropped by the scope filter or by a delete/upload race used to leave no trace anywhere - the
+* turn ran as though the file had never been attached (#2228). Callers report `missingIds` through
+* the same channel as the per-file notices rather than inferring the drop from a shorter array.
+*/
+async function fetchAndConvertFabFiles(fabFileIds, { scope, lakeAccess }, { db, storage, logger }) {
+	const fabFiles = await db.fabfiles.getAccessibleFiles(fabFileIds, scope, lakeAccess);
+	const files = await Promise.all(fabFiles.map(async (file) => {
 		return {
 			...file,
 			userId: file.userId.toString()
 		};
 	}));
+	const returnedIds = new Set(files.map((file) => String(file.id)));
+	const missingIds = Array.from(new Set(fabFileIds)).filter((id) => !returnedIds.has(String(id)));
+	if (missingIds.length > 0) logger?.warn(`[fetchAndConvertFabFiles] ${missingIds.length} of ${fabFileIds.length} requested file id(s) were not returned by getAccessibleFiles and contribute nothing to this turn: ${missingIds.join(", ")}`);
+	return {
+		files,
+		missingIds
+	};
 }
 async function getCachedSignedUrl(filePath, storage, db) {
 	const key = `cachedSignedUrl:${filePath}`;
@@ -30458,7 +32109,7 @@ async function cosineSearch(file, userPromptVector, { db, logger }) {
 		for (const chunk of usable) {
 			const position = scanned;
 			scanned++;
-			if (head.length < COSINE_SEARCH_TOP_K) head.push({
+			if (head.length < 10) head.push({
 				chunkId: chunk.id,
 				content: chunk.text,
 				score: 0
@@ -30479,9 +32130,9 @@ async function cosineSearch(file, userPromptVector, { db, logger }) {
 				position
 			});
 		}
-		if (ranked.length > COSINE_SEARCH_TOP_K) {
+		if (ranked.length > 10) {
 			ranked.sort(compareRankedChunks);
-			ranked.length = COSINE_SEARCH_TOP_K;
+			ranked.length = 10;
 		}
 		if (!moreExist) break;
 	}
@@ -30503,14 +32154,14 @@ const noopResize = async (imageBuffer) => imageBuffer;
 async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, attachedContentTokenBudget, modelInfo, sendStatusUpdate, { logger, storage, db, resizeImageForModel = noopResize }, progressCallback) {
 	if (!fabFiles || fabFiles.length === 0) return {
 		userMessages: [],
-		errorMessages: [],
+		fileNotices: [],
 		deliveredFileIds: [],
 		fullyDeliveredFileIds: []
 	};
 	const fileProcessingStartTime = Date.now();
 	let systemContent = "";
 	const userMessages = [];
-	const errorMessages = [];
+	const fileNotices = [];
 	const deliveredFileIds = /* @__PURE__ */ new Set();
 	const fullyDeliveredFileIds = /* @__PURE__ */ new Set();
 	const contextFiles = [];
@@ -30541,11 +32192,25 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 		try {
 			if (isAudioMimeType(file.mimeType)) {
 				logger.warn(`[processFabFilesServer] Skipping audio file ${file.fileName} — audio is not attachable to an LLM.`);
+				fileNotices.push({
+					fabFileId: file.id,
+					fileName: file.fileName,
+					band: "audio",
+					message: `"${noticeFileName(file.fileName)}" is an audio file and was not sent: no model accepts audio as input.`,
+					delivered: false
+				});
 				return;
 			}
 			if (supportsVision && isImageAttachment(file.mimeType)) {
 				if (!isImageServeable(file)) {
 					logger.warn(`[processFabFilesServer] Skipping image file ${file.fileName} — held pending moderation or blocked (#9776 Q2b).`);
+					fileNotices.push({
+						fabFileId: file.id,
+						fileName: file.fileName,
+						band: "image_not_serveable",
+						message: `Image "${noticeFileName(file.fileName)}" was not sent: it is held pending moderation or has been blocked.`,
+						delivered: false
+					});
 					return;
 				}
 				sendStatusUpdate(`Processing image file ${file.fileName}...`);
@@ -30554,7 +32219,8 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 				switch (modelInfo?.backend) {
 					case ModelBackend.OpenAI:
 					case ModelBackend.XAI:
-					case ModelBackend.Kimi: {
+					case ModelBackend.Kimi:
+					case ModelBackend.DeepSeek: {
 						const openaiImageBuffer = await storage.download(file.filePath);
 						const { mime: openaiMimeType } = await getFileType(openaiImageBuffer, file.fileName, file.mimeType);
 						const openaiBase64 = openaiImageBuffer.toString("base64");
@@ -30581,9 +32247,12 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 								const errorMsg = `⚠️ Image "${file.fileName}" (${fileSizeMB.toFixed(1)}MB) is too large for ${backendName}. Max: ${MAX_IMAGE_SIZE_MB}MB. Please delete this file and re-upload to auto-resize.`;
 								logger.warn(errorMsg);
 								await sendStatusUpdate(errorMsg);
-								errorMessages.push({
-									role: "error",
-									content: errorMsg
+								fileNotices.push({
+									fabFileId: file.id,
+									fileName: file.fileName,
+									band: "image_too_large",
+									message: errorMsg,
+									delivered: false
 								});
 								return;
 							}
@@ -30613,9 +32282,12 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 								const errorMsg = `⚠️ Image "${file.fileName}" (${encodedMB}MB encoded) is too large for ${modelInfo.name}. Max ~3MB. Please delete this file and re-upload a smaller image.`;
 								logger.warn(errorMsg);
 								await sendStatusUpdate(errorMsg);
-								errorMessages.push({
-									role: "error",
-									content: errorMsg
+								fileNotices.push({
+									fabFileId: file.id,
+									fileName: file.fileName,
+									band: "image_too_large",
+									message: errorMsg,
+									delivered: false
 								});
 								return;
 							}
@@ -30629,7 +32301,16 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 							});
 							delivered = true;
 							fullyDelivered = true;
-						} else logger.warn(`Vision support for the model ${modelInfo.id} is not implemented. Skipping image processing.`);
+						} else {
+							logger.warn(`Vision support for the model ${modelInfo.id} is not implemented. Skipping image processing.`);
+							fileNotices.push({
+								fabFileId: file.id,
+								fileName: file.fileName,
+								band: "vision_unsupported",
+								message: `Image "${noticeFileName(file.fileName)}" was not sent: image input is not implemented for ${modelInfo.name ?? modelInfo.id}.`,
+								delivered: false
+							});
+						}
 						break;
 					case ModelBackend.Ollama: {
 						const imageBuffer = await resizeImageForModel(await storage.download(file.filePath), void 0, logger);
@@ -30658,10 +32339,26 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 						fullyDelivered = true;
 						break;
 					}
-					default: logger.error(`Unsupported backend for model ${modelInfo.id} backend ${modelInfo?.backend ?? "undefined"}`);
+					default:
+						logger.error(`Unsupported backend for model ${modelInfo.id} backend ${modelInfo?.backend ?? "undefined"}`);
+						fileNotices.push({
+							fabFileId: file.id,
+							fileName: file.fileName,
+							band: "unsupported_backend",
+							message: `Image "${noticeFileName(file.fileName)}" was not sent: this model's backend does not accept image attachments.`,
+							delivered: false
+						});
 				}
-			} else if (!supportsVision && isImageAttachment(file.mimeType)) logger.warn(`File ${file.fileName} is an image but model does not support vision. Skipping...`);
-			else {
+			} else if (!supportsVision && isImageAttachment(file.mimeType)) {
+				logger.warn(`File ${file.fileName} is an image but model does not support vision. Skipping...`);
+				fileNotices.push({
+					fabFileId: file.id,
+					fileName: file.fileName,
+					band: "vision_unsupported",
+					message: `Image "${noticeFileName(file.fileName)}" was not sent: ${modelInfo?.name ?? modelInfo?.id ?? "this model"} cannot read images.`,
+					delivered: false
+				});
+			} else {
 				const embeddingModel = file.embeddingModel ?? OpenAIEmbeddingModel.TEXT_EMBEDDING_ADA_002;
 				const userVector = userVectorPrompt[embeddingModel];
 				const canCosineSearch = file.vectorized && !!userVector && userVector.length > 0;
@@ -30737,9 +32434,12 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 						const originalFileSize = fabContent.length;
 						fabContent = fabContent.substring(0, finalMaxFileSize ?? PREVIEW_CHUNK) + CONTENT_TRUNCATION_NOTICE;
 						errorMsg = `Knowledge in the workbench with the fileName ${file.fileName} is ${originalFileSize} long which exceeds ${finalMaxFileSize}. ` + (canCosineSearch ? "None of its vectorized chunks could be searched with this turn's embedding model, so it was sent as raw text and truncated. Re-vectorize it under the current embedding model, or select a model with a higher context window." : "Vectorize your large file or select a model with higher context window.");
-						errorMessages.push({
-							role: "error",
-							content: errorMsg
+						fileNotices.push({
+							fabFileId: file.id,
+							fileName: file.fileName,
+							band: "truncated",
+							message: `"${noticeFileName(file.fileName)}" was too large to send whole; only the first ${Math.floor(finalMaxFileSize)} characters of ${originalFileSize} reached this conversation.`,
+							delivered: true
 						});
 					} else errorMsg = null;
 					delivered = true;
@@ -30753,19 +32453,41 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 						error: errorMsg
 					});
 				} catch (e) {
-					if (e instanceof BadRequestError && e.message.includes("Unsupported file type")) logger.warn(`Unsupported file type: ${file.fileName}`);
-					else if (isAxiosError(e) && e.response?.status === 404) {
+					if (e instanceof BadRequestError && e.message.includes("Unsupported file type")) {
+						logger.warn(`Unsupported file type: ${file.fileName}`);
+						fileNotices.push({
+							fabFileId: file.id,
+							fileName: file.fileName,
+							band: "unsupported_type",
+							message: `"${noticeFileName(file.fileName)}" was not sent: its file type (${file.mimeType}) cannot be read as text.`,
+							delivered: false
+						});
+					} else if (isAxiosError(e) && e.response?.status === 404) {
 						await sendStatusUpdate(`Skipping file ${file.fileName}. File might be corrupted or deleted`);
 						await db.fabfiles.update({
 							id: file.id,
 							error: "This file appears to be corrupted or may have been deleted. Please try uploading the file again."
 						});
+						fileNotices.push({
+							fabFileId: file.id,
+							fileName: file.fileName,
+							band: "read_failed",
+							message: `"${noticeFileName(file.fileName)}" could not be read and was not sent: it appears to be corrupted or deleted. Try uploading it again.`,
+							delivered: false
+						});
 					} else if (e instanceof CorruptedFileError) {
 						await sendStatusUpdate(`Skipping corrupted file ${file.fileName}. Please try re-uploading`);
 						await db.fabfiles.update({
 							id: file.id,
 							error: e.message
 						});
+						fileNotices.push({
+							fabFileId: file.id,
+							fileName: file.fileName,
+							band: "read_failed",
+							message: `"${noticeFileName(file.fileName)}" could not be read and was not sent: ${e.message}`,
+							delivered: false
+						});
 					} else {
 						logger.updateMetadata({ filePath: file.filePath });
 						throw e;
@@ -30785,6 +32507,18 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 		processedFiles++;
 		if (progressCallback) await progressCallback(processedFiles, totalFiles);
 	}))));
+	const noticedFileIds = new Set(fileNotices.map((notice) => notice.fabFileId));
+	for (const file of fabFiles) {
+		if (deliveredFileIds.has(file.id) || noticedFileIds.has(file.id)) continue;
+		logger.warn(`[processFabFilesServer] "${file.fileName}" (${file.id}) contributed no content and produced no notice; reporting it as undelivered.`);
+		fileNotices.push({
+			fabFileId: file.id,
+			fileName: file.fileName,
+			band: "no_readable_content",
+			message: `"${noticeFileName(file.fileName)}" was not sent: no readable content could be extracted from it.`,
+			delivered: false
+		});
+	}
 	if (imageContent.length > 0) userMessages.push({
 		role: "user",
 		content: imageContent
@@ -30812,7 +32546,7 @@ async function processFabFilesServer(embeddingFactory, fabFiles, userPrompt, att
 	logger.info(`📁 File processing completed in ${fileProcessingTime}ms for ${fabFiles.length} files`);
 	return {
 		userMessages,
-		errorMessages,
+		fileNotices,
 		deliveredFileIds: Array.from(deliveredFileIds),
 		fullyDeliveredFileIds: Array.from(fullyDeliveredFileIds)
 	};
@@ -31337,6 +33071,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,
+	COSINE_SEARCH_TOP_K: () => 10,
 	DEFAULT_OUTPUT_MAX_TOKENS: () => DEFAULT_OUTPUT_MAX_TOKENS,
 	EXTRACTION_SYSTEM_RESERVE_MAX_SHARE: () => EXTRACTION_SYSTEM_RESERVE_MAX_SHARE,
 	FORMAT_PROMPT_PRIORITY: () => 60,
@@ -32955,6 +34690,7 @@ const OPENAI_IMAGE_CLIENT_OPTS = {
 	maxRetries: 0
 };
 const ALTERNATIVE_IMAGE_MODELS = "Flux Pro, Flux Dev, or Grok";
+const truncatePromptForLog = (prompt) => prompt.length > 100 ? `${prompt.slice(0, 100)}...` : prompt;
 /**
 * Builds a user-friendly error when OpenAI's safety system blocks an image
 * request, guiding the user to rephrase or switch to an alternative model.
@@ -32982,6 +34718,53 @@ function buildModerationBlockedError(error) {
 
 Tip: Switch to an alternative model with different content policies — e.g. ${ALTERNATIVE_IMAGE_MODELS} — which may accept this prompt.\n\nIf you believe this is an error, you can report it to OpenAI with request ID: ${requestId}`);
 }
+/**
+* Splits a WIDTHxHEIGHT size into its two edges, or null when the value is not a
+* pair of non-zero numbers (e.g. 'auto', '', 'wide'). Null means "not a custom
+* resolution" rather than "invalid": generate() has always left such values
+* untouched, and that behaviour is preserved.
+*/
+function parseSizeEdges(size) {
+	if (typeof size !== "string") return null;
+	const [width, height] = size.split("x").map(Number);
+	if (!width || !height) return null;
+	return {
+		width,
+		height
+	};
+}
+/**
+* True when a custom gpt-image-2 resolution meets OpenAI's documented limits.
+* gpt-image-2 accepts any resolution satisfying these, not only the presets in
+* OPENAI_GPT_IMAGE_2_IMAGE_SIZES, so a flat preset check would reject valid
+* custom sizes. Must stay the single source of this rule for generate() and edit().
+*/
+function satisfiesGptImage2Constraints({ width, height }) {
+	const { maxEdge, minTotalPixels, maxTotalPixels, edgeMultiple, maxAspectRatio } = IMAGE_SIZE_CONSTRAINTS.GPT_IMAGE_2.constraints;
+	const longEdge = Math.max(width, height);
+	const shortEdge = Math.min(width, height);
+	const totalPixels = width * height;
+	return longEdge <= maxEdge && width % edgeMultiple === 0 && height % edgeMultiple === 0 && longEdge / shortEdge <= maxAspectRatio && totalPixels >= minTotalPixels && totalPixels <= maxTotalPixels;
+}
+/**
+* True when `size` may be forwarded to images.edit for `model`. gpt-image-2 takes
+* its presets (including 'auto') or any custom WIDTHxHEIGHT meeting the same
+* constraints generate() enforces; the gpt-image-1 family is limited to its three
+* fixed sizes. An unsupported size is dropped by the caller so OpenAI applies its
+* own default instead of rejecting the whole request with a 400.
+*
+* GPT-Image tiers only: dall-e-2 has its own size list and passes size through
+* untouched, so do not route that model here.
+*/
+function isSupportedEditSize(model, size) {
+	if (typeof size !== "string") return false;
+	if (isGPTImage2Model(model)) {
+		if (OPENAI_GPT_IMAGE_2_IMAGE_SIZES.includes(size)) return true;
+		const edges = parseSizeEdges(size);
+		return edges !== null && satisfiesGptImage2Constraints(edges);
+	}
+	return OPENAI_GPT_IMAGE_1_IMAGE_SIZES.includes(size);
+}
 var OpenAIImageService = class extends AIImageService {
 	async generate(prompt, options) {
 		const openai = new OpenAI({
@@ -33006,16 +34789,11 @@ var OpenAIImageService = class extends AIImageService {
 				}
 				if (isGPTImage2Model(options.model)) {
 					if (openaiOptions.size && openaiOptions.size !== "auto") {
-						const [w, h] = openaiOptions.size.split("x").map(Number);
-						if (w && h) {
-							const maxEdge = Math.max(w, h);
-							const minEdge = Math.min(w, h);
-							const totalPixels = w * h;
-							if (maxEdge > 3840 || w % 16 !== 0 || h % 16 !== 0 || maxEdge / minEdge > 3 || totalPixels < 655360 || totalPixels > 8294400) {
-								const originalSize = openaiOptions.size;
-								openaiOptions.size = "1024x1024";
-								parameterWarnings.push(`Size '${originalSize}' violates gpt-image-2 constraints, changed to '1024x1024'`);
-							}
+						const edges = parseSizeEdges(openaiOptions.size);
+						if (edges && !satisfiesGptImage2Constraints(edges)) {
+							const originalSize = openaiOptions.size;
+							openaiOptions.size = "1024x1024";
+							parameterWarnings.push(`Size '${originalSize}' violates gpt-image-2 constraints, changed to '1024x1024'`);
 						}
 					} else if (!openaiOptions.size) openaiOptions.size = "auto";
 				} else {
@@ -33068,6 +34846,10 @@ var OpenAIImageService = class extends AIImageService {
 				const imageFile = new File([pngBuffer], "image.png", { type: "image/png" });
 				if (isGPTImageModel(options.model)) {
 					const editModel = options.model || ImageModels.GPT_IMAGE_2;
+					this.logger.log("OpenAI image generation request (edit endpoint, image-to-image):", {
+						model: editModel,
+						prompt: truncatePromptForLog(prompt)
+					});
 					result = await openai.images.edit({
 						model: editModel,
 						image: [imageFile],
@@ -33075,20 +34857,31 @@ var OpenAIImageService = class extends AIImageService {
 					});
 				} else {
 					const { style, quality, model, ...opts } = openaiOptions;
+					const variationSize = [
+						"256x256",
+						"512x512",
+						"1024x1024"
+					].find((s) => s === openaiOptions.size);
+					this.logger.log("OpenAI image generation request (variation endpoint):", {
+						...opts,
+						size: variationSize
+					});
 					result = await openai.images.createVariation({
 						...opts,
 						image: imageFile,
-						size: [
-							"256x256",
-							"512x512",
-							"1024x1024"
-						].find((s) => s === openaiOptions.size)
+						size: variationSize
 					});
 				}
-			} else result = await openai.images.generate({
-				prompt,
-				...openaiOptions
-			});
+			} else {
+				this.logger.log("OpenAI image generation request:", {
+					prompt: truncatePromptForLog(prompt),
+					...openaiOptions
+				});
+				result = await openai.images.generate({
+					prompt,
+					...openaiOptions
+				});
+			}
 			images = this.imageResponseToUrl(result);
 			return images;
 		} catch (error) {
@@ -33145,10 +34938,21 @@ var OpenAIImageService = class extends AIImageService {
 				Logger.globalInstance.debug(`[DEBUG] ⚠️ Edit endpoint doesn't support ${model}, defaulting to gpt-image-2`);
 				editModel = ImageModels.GPT_IMAGE_2;
 			}
+			const forwardSize = isSupportedEditSize(editModel, size);
+			this.logger.log("OpenAI image edit request:", {
+				model: editModel,
+				prompt: truncatePromptForLog(prompt),
+				hasMask: !!maskFile,
+				n,
+				size,
+				response_format
+			});
 			const response = await openai.images.edit(isGPTImageModel(editModel) ? {
 				model: editModel,
 				image: [imageFile],
-				prompt
+				prompt,
+				...forwardSize ? { size } : {},
+				...maskFile ? { mask: maskFile } : {}
 			} : {
 				model: editModel,
 				image: imageFile,
@@ -35175,6 +36979,21 @@ var TiktokenTokenizer = class {
 		return Array.from(encoder.encode_ordinary(text));
 	}
 	/**
+	* Decode token ids back to text through the same encoder encodeTokens used, so an
+	* encode -> slice -> decode round trip yields real text rather than the ids themselves.
+	* @param tokens - Token ids, typically a slice of an encodeTokens result
+	* @param modelId - Model ID to determine encoding (must match the one used to encode)
+	* @returns Promise<string> - The decoded text
+	*
+	* tiktoken's wasm decode() hands back raw UTF-8 bytes. A slice that ends mid-character therefore
+	* decodes to a trailing U+FFFD; callers that sliced are expected to trim it.
+	*/
+	async decodeTokens(tokens, modelId, logger) {
+		if (this.isShuttingDown) throw new Error("TiktokenTokenizer is shutting down");
+		const encoder = await this.getEncoder(modelId, logger);
+		return new TextDecoder().decode(encoder.decode(new Uint32Array(tokens)));
+	}
+	/**
 	* Returns a lightweight ITokenizer proxy that delegates WASM encoder operations
 	* to this instance (preserving the shared encoder cache) but routes log output
 	* through the provided logger. Useful for attaching per-request context (e.g.
@@ -35183,7 +37002,8 @@ var TiktokenTokenizer = class {
 	withLogger(logger) {
 		return {
 			countTokens: (text, modelId) => this.countTokens(text, modelId, logger),
-			encodeTokens: (text, modelId) => this.encodeTokens(text, modelId, logger)
+			encodeTokens: (text, modelId) => this.encodeTokens(text, modelId, logger),
+			decodeTokens: (tokens, modelId) => this.decodeTokens(tokens, modelId, logger)
 		};
 	}
 	/**
@@ -35643,6 +37463,7 @@ __reExport(/* @__PURE__ */ __exportAll({
 	BaseStorage: () => BaseStorage,
 	BedrockEmbeddingService: () => BedrockEmbeddingService,
 	CONTENT_TYPE_BY_FORMAT: () => CONTENT_TYPE_BY_FORMAT,
+	COSINE_SEARCH_TOP_K: () => 10,
 	CacheKeys: () => CacheKeys,
 	ChunkSchema: () => ChunkSchema,
 	CircuitBreaker: () => CircuitBreaker,
@@ -35737,6 +37558,7 @@ __reExport(/* @__PURE__ */ __exportAll({
 	checkStorageLimit: () => checkStorageLimit,
 	checkStorageLimitForFile: () => checkStorageLimitForFile,
 	cleanMermaidSyntax: () => cleanMermaidSyntax,
+	computeContentHash: () => computeContentHash,
 	computeCosineSimilarity: () => computeCosineSimilarity,
 	computeVerbatimTokenBudget: () => computeVerbatimTokenBudget,
 	convertCodeBlocksToArtifacts: () => convertCodeBlocksToArtifacts,
@@ -35808,7 +37630,9 @@ __reExport(/* @__PURE__ */ __exportAll({
 	registerLambdaErrorHandlers: () => registerLambdaErrorHandlers,
 	registerProcessErrorHandlers: () => registerProcessErrorHandlers,
 	registrableDomain: () => registrableDomain,
+	reservationOutputTokens: () => reservationOutputTokens,
 	resolveEmbeddingConfig: () => resolveEmbeddingConfig,
+	resolveEmbeddingWithKeylessFallback: () => resolveEmbeddingWithKeylessFallback,
 	resolveSupportedMimeType: () => resolveSupportedMimeType,
 	safeInputWindow: () => safeInputWindow,
 	scopedOverrideKey: () => scopedOverrideKey,