@bike4mind/cli 0.21.0 → 0.22.0

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as SupportedFabFileMimeTypes, $t as buildRateLimitLogEntry, A as HTTPError, At as isRenderableModelType, B as OPENAI_GPT_IMAGE_1_IMAGE_SIZES, Bt as resolveHistoryFetchLimit, Ct as isGeminiModelId, D as FIXED_TEMPERATURE_MODELS, Dt as isModelAccessible, E as FIELD_GROUP_OF, Et as isMediaModelType, F as MODEL_INFO_FIELD_GROUP_OF, Ft as isZodError, G as PermissionDeniedError, Gt as usdToCredits, H as OllamaEmbeddingModel, Ht as settingsMap, I as McpServerName, It as mapMimeTypeToArtifactType, J as REFUSAL_FALLBACK_MODELS, K as REASONING_EFFORT_INCOMPATIBLE_WITH_TOOLS_MODELS, Kt as usdToCreditsStochastic, L as ModelBackend, Lt as obfuscateApiKey, M as IMAGE_SIZE_CONSTRAINTS, Mt as isSupportedFabFileMimeType, N as ImageModels, Nt as isUnlimitedHistory, O as FORMAT_PROMPT_TEMPLATE, Ot as isModelDeprecated, P as InternalServerError, Pt as isUserInitiatedAbort, Q as SpeechToTextModels, R as NO_TEMPERATURE_MODELS, Rt as parseEmbeddingRateLimitHeaders, S as CorruptedFileError, St as isGPTImageModel, Tt as isImageServeable, U as OpenAIEmbeddingModel, Ut as toModelInfo, V as OPENAI_GPT_IMAGE_2_IMAGE_SIZES, Vt as secureParameters, Wt as toModelRecord, Y as RESPONSES_API_TOOL_MODELS, _ as BadRequestError, _t as isChunkRebuildPending, at as VideoModels, bt as isFieldGroup, ct as applyModelPriceCatalog, dt as defaultEmbeddingModelForEnv, en as extractSnippetMeta, et as TTS_MAX_INPUT_CHARS, ft as getMcpProviderMetadata, g as BFL_SAFETY_TOLERANCE, gt as isAudioMimeType, h as BEDROCK_NO_PROMPT_CACHING_MODELS, ht as hasUsableLimits, it as VIDEO_SIZE_CONSTRAINTS, j as HttpStatus, jt as isRetryableError, k as ForbiddenError, kt as isPlaceholderApiKey, lt as calculateRetryDelay, m as ApiKeyType, mt as getRetryAfterMs, n as logger, nn as parseRateLimitHeaders, nt as UnauthorizedError, ot as VoyageAIEmbeddingModel, p as ARTIFACT_ATTRS_PATTERN, pt as getQuestErrorCode, q as REASONING_SUPPORTED_MODELS, qt as withRetry, rt as UnprocessableEntityError, st as WORK_ITEM_STATUSES, tn as isNearLimit, tt as TooManyRequestsError, ut as dayjsConfig_default, v as BedrockEmbeddingModel, vt as isChunkStalledFile, w as DEFAULT_UNKNOWN_CONTEXT_WINDOW, wt as isImageAttachment, x as ChatModels, xt as isGPTImage2Model, y as CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS, z as NotFoundError, zt as reservationOutputTokens } from "./ConfigStore-CoY0l0gr.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,7 +49,6 @@ 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";
@@ -921,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"
@@ -978,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",
@@ -986,6 +988,7 @@ const getEffectiveLLMApiKeys = async (userId, adapters, options) => {
 		"bflApiKey",
 		"xaiApiKey",
 		"moonshotApiKey",
+		"deepseekApiKey",
 		"voyageApiKey",
 		"ollamaBackend",
 		"EnableOllama"
@@ -998,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"];
@@ -1005,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"];
@@ -1023,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")
@@ -2088,7 +2094,7 @@ const webSearchTool = {
 	})
 };
 //#endregion
-//#region ../../b4m-core/services/dist/toolGenerators-hk-Robqc.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();
@@ -2656,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.
@@ -4268,7 +4295,7 @@ 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 && model.userId === context.userId) {
 					const existingIndex = model.data.entities.findIndex((e) => e.id === entityId);
@@ -4412,7 +4439,7 @@ 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 && model.userId === context.userId) {
 					const entity = model.data.entities.find((e) => e.id === entityId || e.name === entityName);
@@ -4547,7 +4574,7 @@ 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 && model.userId === context.userId) {
 					if (!model.data.entities.some((e) => e.id === outputEntityId || e.name.toLowerCase() === parsedRule.outputEntity.toLowerCase()) && parsedRule.outputEntity !== "unknown") {
@@ -7230,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.
@@ -7250,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) {
@@ -7273,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()
@@ -10099,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
@@ -15940,6 +16051,10 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	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,
@@ -15947,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,
@@ -15967,6 +16083,7 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	UndifferentiatedBedrockBackend: () => UndifferentiatedBedrockBackend,
 	UnsupportedAdapterFamilyError: () => UnsupportedAdapterFamilyError,
 	XAIBackend: () => XAIBackend,
+	adapterPriceTiers: () => adapterPriceTiers,
 	backendForAdapterFamily: () => backendForAdapterFamily,
 	buildApiKeyTable: () => buildApiKeyTable,
 	buildSupersededIndex: () => buildSupersededIndex,
@@ -15977,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,
@@ -16011,6 +16132,7 @@ var dist_exports = /* @__PURE__ */ __exportAll$3({
 	splitCacheInclusiveInput: () => splitCacheInclusiveInput,
 	stripAllToolBlocks: () => stripAllToolBlocks,
 	stripToolDependentMessages: () => stripToolDependentMessages,
+	toDeepSeekEffort: () => toDeepSeekEffort,
 	toKimiEffort: () => toKimiEffort,
 	toProviderEndUserId: () => toProviderEndUserId,
 	updateReplacedByOverlay: () => updateReplacedByOverlay
@@ -16726,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) {
@@ -16759,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(),
@@ -16809,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
@@ -17332,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",
@@ -17355,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."
@@ -17375,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",
@@ -17422,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."
@@ -17445,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."
@@ -17538,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",
@@ -17562,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.",
@@ -19407,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 [
 			{
@@ -19531,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",
@@ -19554,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",
@@ -19577,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",
@@ -19600,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."
@@ -19620,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",
@@ -19667,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."
@@ -19690,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."
@@ -19711,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",
@@ -19735,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",
@@ -19759,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",
@@ -20415,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."
 		}];
 	}
@@ -21511,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."
@@ -22267,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.
-*
-* getTextModelCost expects Anthropic's convention: `inputTokens` counts only uncached
-* tokens and cache reads bill separately at their own (much cheaper) rate. Anthropic
-* and Claude-on-Bedrock deliver that natively. OpenAI and Moonshot do not - their
-* prompt total already CONTAINS the cached tokens - so those adapters must subtract
-* here before forwarding, or settlement double-bills the cached portion.
-*
-* Must stay in sync with the disjoint-fields assumption documented at the settlement
-* site in ChatCompletionProcess.
-*/
-/**
-* Split a cache-INCLUSIVE prompt total into the disjoint pair CompletionInfo carries.
-*
-* Forwarding the cached count without subtracting double-bills it; forwarding nothing
-* charges the full input rate on tokens the provider billed at a fraction of it.
-* Subtracting is the only split that bills what the provider actually charged.
-*
-* Clamped at zero: if a feed ever reports more cached than prompt tokens, a negative
-* input count would silently credit the user.
-*/
-function splitCacheInclusiveInput(totalPromptTokens, cacheReadTokens) {
-	if (cacheReadTokens <= 0) return { inputTokens: totalPromptTokens };
-	const cached = Math.min(cacheReadTokens, totalPromptTokens);
-	return {
-		inputTokens: Math.max(0, totalPromptTokens - cached),
-		cacheReadInputTokens: cached
-	};
-}
-/**
-* Cached prompt tokens from a raw provider usage object, across every spelling in use:
-* OpenAI Chat Completions nests them under `prompt_tokens_details`, the OpenAI
-* Responses API under `input_tokens_details`, and Moonshot publishes a flat
-* `cached_tokens` alongside the OpenAI-shaped nesting. Reading only one spelling
-* silently bills every cache hit on the other transports at the full input rate.
-*/
-function cachedTokensFromUsage(usage) {
-	if (!usage) return 0;
-	const candidates = [
-		usage.cached_tokens,
-		usage.prompt_tokens_details?.cached_tokens,
-		usage.input_tokens_details?.cached_tokens
-	];
-	for (const value of candidates) if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
-	return 0;
-}
-/**
-* Request shaping for Moonshot's Kimi models. Kept separate from kimiBackend's
-* transport so every "which parameter does this id accept" rule is one pure
-* function with a test, rather than a conditional buried in a 400-line complete().
+* 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().
 *
-* 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
+* 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
 */
-/** 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
-]);
+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;
 /**
-* `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.
+* 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.
 */
-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) {
+function toDeepSeekEffort(effort) {
 	if (!effort) return void 0;
 	switch (effort) {
 		case "none":
@@ -22386,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) {
@@ -22450,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);
@@ -22493,8 +22668,614 @@ 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));
+}
+/**
+* DeepSeek's models, served from their own OpenAI-compatible endpoint.
+*
+* Structurally this is kimiBackend's twin - same OpenAI SDK against a different
+* baseURL, same recursive tool loop, same multi-turn token accumulators - and the
+* three OpenAI-compatible backends must stay in sync on that machinery. What
+* genuinely differs here:
+*
+* 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://api-docs.deepseek.com/api/create-chat-completion
+*/
+var DeepSeekBackend = class {
+	_baseUrl = "https://api.deepseek.com";
+	_api;
+	logger;
+	currentModel = "";
+	constructor(apiKey, logger) {
+		if (!apiKey) throw new Error("DeepSeek 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. 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.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;
+		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;
+		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(messagesWithFormat)
+		};
+		Object.assign(parameters, {
+			...deepseekSamplingParams(model, {
+				temperature: options.temperature,
+				topP: options.topP,
+				presencePenalty: options.presencePenalty,
+				frequencyPenalty: options.frequencyPenalty
+			}, reasoning),
+			...deepseekReasoningParams(model, reasoning),
+			stop: deepseekStopSequences(options.stop),
+			stream: useStreaming,
+			max_tokens: options.maxTokens,
+			...useStreaming && { stream_options: { include_usage: true } }
+		});
+		if (options.tools?.length) {
+			parameters.tools = this.formatTools(options.tools);
+			if (options.tool_choice !== void 0) parameters.tool_choice = options.tool_choice;
+		}
+		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 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.
@@ -22634,6 +23415,8 @@ var KimiBackend = class {
 				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."
 			}
 		];
@@ -22852,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) => {
@@ -23772,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."
 			},
@@ -23793,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."
 			},
@@ -23814,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."
@@ -23878,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.",
@@ -24050,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."
@@ -24116,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."
@@ -24138,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."
@@ -26011,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");
@@ -26051,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,
@@ -26077,6 +26866,7 @@ const KEYED_LISTING_BACKENDS = [
 	ModelBackend.BFL,
 	ModelBackend.XAI,
 	ModelBackend.Kimi,
+	ModelBackend.DeepSeek,
 	ModelBackend.LocalImage
 ];
 /**
@@ -26134,6 +26924,7 @@ const DISPATCHABLE_ADAPTER_FAMILIES = [
 	"gemini",
 	"xai",
 	"kimi",
+	"deepseek",
 	"ollama",
 	"bfl",
 	"local-image",
@@ -26211,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({
@@ -26327,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";
@@ -26591,6 +27400,7 @@ const DEPRECATED_MODEL_MAP = {
 	"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"
 };
 /**
@@ -26715,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
@@ -26755,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",
@@ -26796,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,
@@ -26915,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
 					}
 				};
 			}
@@ -27155,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;
@@ -27249,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,
@@ -27259,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
 	};
@@ -28781,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,
@@ -29630,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.
@@ -31331,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");
@@ -36743,6 +37632,7 @@ __reExport(/* @__PURE__ */ __exportAll({
 	registrableDomain: () => registrableDomain,
 	reservationOutputTokens: () => reservationOutputTokens,
 	resolveEmbeddingConfig: () => resolveEmbeddingConfig,
+	resolveEmbeddingWithKeylessFallback: () => resolveEmbeddingWithKeylessFallback,
 	resolveSupportedMimeType: () => resolveSupportedMimeType,
 	safeInputWindow: () => safeInputWindow,
 	scopedOverrideKey: () => scopedOverrideKey,