librechat-data-provider 0.8.521 → 0.8.523

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_data_service = require("./data-service-DOIF4BkW.js");
+const require_data_service = require("./data-service-CTX0tVO5.js");
 let zod = require("zod");
 let dayjs = require("dayjs");
 dayjs = require_data_service.__toESM(dayjs);
@@ -7,6 +7,7 @@ let dayjs_plugin_utc_js = require("dayjs/plugin/utc.js");
 dayjs_plugin_utc_js = require_data_service.__toESM(dayjs_plugin_utc_js);
 let dayjs_plugin_timezone_js = require("dayjs/plugin/timezone.js");
 dayjs_plugin_timezone_js = require_data_service.__toESM(dayjs_plugin_timezone_js);
+let croner = require("croner");
 let axios = require("axios");
 axios = require_data_service.__toESM(axios);
 let url = require("url");
@@ -190,6 +191,17 @@ function supportsContext1m(model) {
 	return false;
 }
 /**
+* Checks whether a native Anthropic Claude model supports prompt caching.
+*
+* This uses the configured model ID directly. Resolving it through a token
+* map first can collapse a newly released Claude model to the generic
+* `claude-` fallback and incorrectly disable cache control.
+*/
+function supportsPromptCache(model) {
+	if (model.includes("claude-3-5-sonnet-latest") || model.includes("claude-3.5-sonnet-latest")) return false;
+	return /claude-3[-.]7/.test(model) || /claude-3[-.]5-(?:sonnet|haiku)/.test(model) || /claude-3-(?:sonnet|haiku|opus)?/.test(model) || /claude-(?:sonnet|opus|haiku)[-.]?(?:[4-9]|\d{2,})/.test(model) || /claude-(?:[4-9]|\d{2,})(?:[-.](?:sonnet|opus|haiku))?/.test(model) || require_data_service.isMythosClassModel(model);
+}
+/**
 * A Bedrock Claude model ID may be prefixed (`anthropic.claude-*`,
 * `us.anthropic.claude-*`, `global.anthropic.claude-*`) or bare (`claude-*`,
 * used when the LibreChat model ID maps to an application inference profile).
@@ -644,11 +656,14 @@ let StepEvents = /* @__PURE__ */ function(StepEvents) {
 	StepEvents["ON_REASONING_DELTA"] = "on_reasoning_delta";
 	StepEvents["ON_RUN_STEP_DELTA"] = "on_run_step_delta";
 	StepEvents["ON_RUN_STEP_COMPLETED"] = "on_run_step_completed";
+	/** Terminal signal for a run step: closed with a status and timestamps. */
+	StepEvents["ON_RUN_STEP_CLOSED"] = "on_run_step_closed";
 	StepEvents["ON_SUMMARIZE_START"] = "on_summarize_start";
 	StepEvents["ON_SUMMARIZE_DELTA"] = "on_summarize_delta";
 	StepEvents["ON_SUMMARIZE_COMPLETE"] = "on_summarize_complete";
 	StepEvents["ON_SUBAGENT_UPDATE"] = "on_subagent_update";
 	StepEvents["ON_SANDBOX_STARTING"] = "on_sandbox_starting";
+	StepEvents["ON_PTC_TOOL_CALL"] = "on_ptc_tool_call";
 	return StepEvents;
 }({});
 /** Token-tracking event names streamed to the client (separate from StepEvents dispatch). */
@@ -689,6 +704,17 @@ let ActivityLabelEvents = /* @__PURE__ */ function(ActivityLabelEvents) {
 	ActivityLabelEvents["ON_ACTIVITY_LABEL"] = "on_activity_label";
 	return ActivityLabelEvents;
 }({});
+/** Live title updates for an existing reasoning content part. */
+let ReasoningLabelEvents = /* @__PURE__ */ function(ReasoningLabelEvents) {
+	ReasoningLabelEvents["ON_REASONING_LABEL"] = "on_reasoning_label";
+	/** Internal durable budget reservation; clients intentionally do not render it. */
+	ReasoningLabelEvents["ON_REASONING_LABEL_ATTEMPT"] = "on_reasoning_label_attempt";
+	return ReasoningLabelEvents;
+}({});
+const finiteNonNegativeInteger = (value) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	return Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(value)));
+};
 /**
 * Full prompt token count for one completed model call — the EXACT context the
 * model saw, provider-aware: additive providers (Bedrock) report `input_tokens`
@@ -700,37 +726,114 @@ let ActivityLabelEvents = /* @__PURE__ */ function(ActivityLabelEvents) {
 * gauge reconciles its calibrated estimate to.
 */
 const promptTokensFromUsage = (event) => {
-	const input = event.input_tokens ?? 0;
+	const input = finiteNonNegativeInteger(event.input_tokens) ?? 0;
 	const details = event.input_token_details ?? {};
-	const cacheRead = details.cache_read ?? 0;
-	const cacheCreation = details.cache_creation ?? 0;
-	return (event.provider != null ? require_data_service.inputTokensIncludesCache(event.provider) : cacheRead + cacheCreation <= input) ? input : input + cacheRead + cacheCreation;
+	const cacheRead = finiteNonNegativeInteger(details.cache_read) ?? 0;
+	const cacheCreation = finiteNonNegativeInteger(details.cache_creation) ?? 0;
+	return (event.provider != null ? require_data_service.inputTokensIncludesCache(event.provider) : cacheRead + cacheCreation <= input) ? input : Math.min(Number.MAX_SAFE_INTEGER, input + cacheRead + cacheCreation);
+};
+/**
+* Scales per-tool result-message counts while bounding both malformed input and
+* rounding error. Null-prototype records keep tool names as ordinary data keys;
+* cumulative apportionment preserves the scaled sum in one linear pass.
+*/
+const scaleToolMessageTokenCounts = (value, oldTotal, newTotal) => {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return;
+	const scaled = Object.create(null);
+	let remaining = oldTotal;
+	let cumulative = 0;
+	let allocated = 0;
+	let found = false;
+	for (const [name, rawCount] of Object.entries(value)) {
+		const count = finiteNonNegativeInteger(rawCount);
+		if (count == null || count === 0) continue;
+		const bounded = Math.min(count, remaining);
+		remaining -= bounded;
+		cumulative += bounded;
+		const target = oldTotal > 0 ? Math.round(cumulative / oldTotal * newTotal) : 0;
+		const apportioned = target - allocated;
+		allocated = target;
+		if (apportioned > 0) {
+			scaled[name] = apportioned;
+			found = true;
+		}
+	}
+	return found ? scaled : void 0;
 };
 /**
 * Reconciles a pre-invoke context snapshot's CALIBRATED estimate to a call's
 * ACTUAL prompt tokens. The SDK's calibration multiplier scales only
-* `messageTokens` (instructions/summary are raw tiktoken counts), and it can
+* `messageTokens` (instructions/summary are raw tiktoken counts) and can
 * over-shoot badly when a provider injects server-side content the SDK never
 * counted (e.g. Anthropic web search) — pinning the gauge several× too high and
 * persisting it. Trust the provider's own prompt count: keep the raw
-* instruction/summary rows, set `messageTokens` to the remainder, and recompute
-* the free space. No-op when `promptTokens` is unusable.
+* instruction/summary rows, set `messageTokens` to the remainder, recompute the
+* free space, and rescale the `toolMessageTokens` share to the new message
+* total. No-op when `promptTokens` is unusable.
 */
 const reconcileContextUsage = (snapshot, promptTokens) => {
 	if (!Number.isFinite(promptTokens) || promptTokens <= 0) return snapshot;
+	const normalizedPromptTokens = Math.min(Number.MAX_SAFE_INTEGER, Math.floor(promptTokens));
+	if (normalizedPromptTokens <= 0) return snapshot;
 	const { breakdown } = snapshot;
-	const budget = snapshot.contextBudget ?? breakdown.maxContextTokens;
-	const nonMessageTokens = (breakdown.instructionTokens ?? 0) + (breakdown.summaryTokens ?? 0);
-	const messageTokens = Math.max(0, promptTokens - nonMessageTokens);
-	return {
+	const instructionTokens = finiteNonNegativeInteger(breakdown.instructionTokens) ?? 0;
+	const summaryTokens = finiteNonNegativeInteger(breakdown.summaryTokens) ?? 0;
+	const budget = finiteNonNegativeInteger(snapshot.contextBudget) ?? finiteNonNegativeInteger(breakdown.maxContextTokens);
+	const nonMessageTokens = instructionTokens + summaryTokens;
+	const messageTokens = Math.max(0, normalizedPromptTokens - nonMessageTokens);
+	/** `toolMessageTokens` is a subset of the OLD (calibrated) `messageTokens`;
+	* rescale it by the same proportion so the split tracks the provider's real
+	* total. A supplied zero remains a known-zero split; absent fields stay absent
+	* for older snapshots. */
+	const priorMessageTokens = finiteNonNegativeInteger(breakdown.messageTokens) ?? 0;
+	const priorToolMessageTokens = finiteNonNegativeInteger(breakdown.toolMessageTokens);
+	let toolMessageTokens;
+	if (priorToolMessageTokens != null) {
+		toolMessageTokens = 0;
+		if (priorMessageTokens > 0 && priorToolMessageTokens > 0) toolMessageTokens = Math.min(messageTokens, Math.round(Math.min(priorToolMessageTokens, priorMessageTokens) / priorMessageTokens * messageTokens));
+	}
+	const toolMessageTokenCounts = toolMessageTokens != null ? scaleToolMessageTokenCounts(breakdown.toolMessageTokenCounts, Math.min(priorToolMessageTokens ?? 0, priorMessageTokens), toolMessageTokens) : void 0;
+	const nextBreakdown = {
+		...breakdown,
+		instructionTokens,
+		summaryTokens,
+		messageTokens
+	};
+	if (toolMessageTokens == null) {
+		delete nextBreakdown.toolMessageTokens;
+		delete nextBreakdown.toolMessageTokenCounts;
+	} else {
+		nextBreakdown.toolMessageTokens = toolMessageTokens;
+		if (toolMessageTokenCounts == null) delete nextBreakdown.toolMessageTokenCounts;
+		else nextBreakdown.toolMessageTokenCounts = toolMessageTokenCounts;
+	}
+	const result = {
 		...snapshot,
-		breakdown: {
-			...breakdown,
-			messageTokens
-		},
-		remainingContextTokens: budget != null ? Math.max(0, budget - promptTokens) : snapshot.remainingContextTokens
+		breakdown: nextBreakdown
 	};
+	if (budget != null) result.remainingContextTokens = Math.max(0, budget - normalizedPromptTokens);
+	else {
+		const remaining = finiteNonNegativeInteger(snapshot.remainingContextTokens);
+		if (remaining == null) delete result.remainingContextTokens;
+		else result.remainingContextTokens = remaining;
+	}
+	return result;
 };
+/** Provider output, including reasoning omitted from an under-reported output count. */
+const outputTokensFromUsage = (event) => {
+	const output = finiteNonNegativeInteger(event.output_tokens) ?? 0;
+	const total = finiteNonNegativeInteger(event.total_tokens) ?? 0;
+	return Math.max(output, total - promptTokensFromUsage(event));
+};
+/** Reconcile and retain the primary call details on live, saved, and resumable snapshots. */
+const reconcileContextUsageFromEvent = (snapshot, event) => ({
+	...reconcileContextUsage(snapshot, promptTokensFromUsage(event)),
+	model: event.model,
+	provider: event.provider,
+	completedOutputTokens: outputTokensFromUsage(event),
+	cacheRead: finiteNonNegativeInteger(event.input_token_details?.cache_read) ?? 0,
+	cacheWrite: finiteNonNegativeInteger(event.input_token_details?.cache_creation) ?? 0
+});
 //#endregion
 //#region src/parsers.ts
 dayjs.default.extend(dayjs_plugin_utc_js.default);
@@ -964,6 +1067,14 @@ function replaceSpecialVars({ text, user, now: inputNow, timezone }) {
 	return result;
 }
 /**
+* Resolves the display label ("sender") for an ephemeral agent:
+* `modelLabel` (user/preset) → model spec's `label` → endpoint config's
+* `modelDisplayLabel` → `''` (lets consumers fall back to the model name).
+*/
+function getEphemeralSender({ modelLabel, specLabel, modelDisplayLabel }) {
+	return modelLabel ?? specLabel ?? modelDisplayLabel ?? "";
+}
+/**
 * Encodes an ephemeral agent ID from endpoint, model, optional sender, and optional index.
 * Uses __ to replace : (reserved in graph node names) and ___ to separate sender.
 *
@@ -1255,7 +1366,266 @@ function mapGroupToAzureConfig({ groupName, groupMap }) {
 	return result;
 }
 //#endregion
+//#region src/langchain.ts
+/**
+* LangChain classifies a provider failure by mutating the error: it stamps `lc_error_code` and
+* appends `\n\nTroubleshooting URL: <docs url>\n` to the message. Both halves are handled here
+* because the server strips the URL before persisting the message, while the client still reads the
+* code back out of messages persisted before it did.
+*/
+const LANGCHAIN = "langchain";
+const ERROR_PATH = "/errors/";
+const TROUBLESHOOTING_LABEL = "Troubleshooting URL:";
+const WHITESPACE = /\s/;
+/** Provider errors cross untyped boundaries, so a `message` is not guaranteed to be a string. */
+function toMessageText(message) {
+	if (typeof message === "string") return message;
+	return message == null ? "" : String(message);
+}
+function isErrorCodeCharacter(character) {
+	const code = character.charCodeAt(0);
+	return character === "_" || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function findTokenEnd(text, start, limit = text.length) {
+	let end = start;
+	while (end < limit && !WHITESPACE.test(text[end])) end += 1;
+	return end;
+}
+function findErrorCode(text, searchableText, start, end) {
+	const langChainIndex = searchableText.indexOf(LANGCHAIN, start);
+	if (langChainIndex < 0 || langChainIndex >= end) return;
+	let errorCode;
+	let pathIndex = searchableText.indexOf(ERROR_PATH, langChainIndex + 9);
+	while (pathIndex >= 0 && pathIndex < end) {
+		const codeStart = pathIndex + 8;
+		let codeEnd = codeStart;
+		while (codeEnd < end && isErrorCodeCharacter(text[codeEnd])) codeEnd += 1;
+		if (codeEnd > codeStart) errorCode = {
+			start: codeStart,
+			end: codeEnd
+		};
+		pathIndex = searchableText.indexOf(ERROR_PATH, Math.max(codeStart, codeEnd));
+	}
+	return errorCode;
+}
+/** Removes LangChain's appended docs URL so provider text carries no third-party attribution. */
+function stripLangChainTroubleshootingUrl(message) {
+	const text = toMessageText(message);
+	const parts = [];
+	let copiedUntil = 0;
+	let searchFrom = 0;
+	while (searchFrom < text.length) {
+		const labelStart = text.indexOf(TROUBLESHOOTING_LABEL, searchFrom);
+		if (labelStart < 0) break;
+		let matchStart = labelStart;
+		while (matchStart > copiedUntil && WHITESPACE.test(text[matchStart - 1])) matchStart -= 1;
+		let urlStart = labelStart + 20;
+		while (urlStart < text.length && WHITESPACE.test(text[urlStart])) urlStart += 1;
+		if (!text.startsWith("https://", urlStart) && !text.startsWith("http://", urlStart)) {
+			searchFrom = urlStart;
+			continue;
+		}
+		const urlEnd = findTokenEnd(text, urlStart);
+		const errorCode = findErrorCode(text, text, urlStart, urlEnd);
+		if (errorCode == null) {
+			searchFrom = urlEnd;
+			continue;
+		}
+		let matchEnd = errorCode.end;
+		if (text[matchEnd] === "/") matchEnd += 1;
+		while (matchEnd < text.length && WHITESPACE.test(text[matchEnd])) matchEnd += 1;
+		parts.push(text.slice(copiedUntil, matchStart), " ");
+		copiedUntil = matchEnd;
+		searchFrom = matchEnd;
+	}
+	parts.push(text.slice(copiedUntil));
+	return parts.join("").trim();
+}
+/** The classification LangChain encoded in the docs URL it appended, when the text carries one. */
+function parseLangChainErrorCode(message) {
+	const text = toMessageText(message);
+	const searchableText = text.toLowerCase();
+	let searchFrom = 0;
+	while (searchFrom < text.length) {
+		const langChainIndex = searchableText.indexOf(LANGCHAIN, searchFrom);
+		if (langChainIndex < 0) return;
+		const tokenEnd = findTokenEnd(text, langChainIndex);
+		const errorCode = findErrorCode(text, searchableText, langChainIndex, tokenEnd);
+		if (errorCode != null) return text.slice(errorCode.start, errorCode.end).toUpperCase();
+		searchFrom = tokenEnd + 1;
+	}
+}
+//#endregion
+//#region src/resolve-llm-delivery-path.ts
+/** Audio and video reach the model only through the media encoders, which support a
+*  narrower provider set than documents. Images use the broadly supported vision
+*  path and are never gated here. */
+const isProviderCapable = (mimeType, endpoint, useResponsesApi) => {
+	if (mimeType.startsWith("audio/") || mimeType.startsWith("video/")) return require_data_service.isMediaSupportedProvider(endpoint);
+	if (mimeType === "application/pdf") return useResponsesApi === true || require_data_service.isDocumentSupportedProvider(endpoint);
+	return true;
+};
+const SYSTEM_LLM_DELIVERY_DEFAULTS = {
+	fallback: "text",
+	overrides: {
+		"image/*": "provider",
+		"video/*": "provider",
+		"audio/*": "provider",
+		"application/pdf": "provider"
+	}
+};
+/**
+* Types some step in the upload pipeline can turn into text: natively readable text,
+* documents a parser or OCR handles, images through OCR, and audio through transcription.
+*
+* Everything absent from this list, notably archives, tarballs, columnar data files and
+* video, has no such step, and the default text matcher accepts any well-formed type, so
+* routing them to text ends in their bytes being decoded as UTF-8.
+*/
+const TEXT_RECOVERABLE_MIME_TYPES = [
+	/^text\//,
+	/^image\//,
+	/^audio\//,
+	/^application\/(json|javascript|xml|sql|yaml|x-yaml|csv|typescript|x-sh|vnd\.coffeescript)$/,
+	/^application\/pdf$/,
+	/^application\/vnd\.openxmlformats-officedocument\.(wordprocessingml\.document|spreadsheetml\.sheet)$/,
+	/^application\/vnd\.oasis\.opendocument\.(text|spreadsheet)$/,
+	/^application\/(vnd\.ms-excel|x-msexcel|msexcel|x-ms-excel|x-excel|x-dos_ms_excel|xls|x-xls)$/,
+	/^message\/rfc822$/
+];
+/**
+* Types whose bytes are text already, so reading them directly is meaningful. Everything
+* else needs a real extractor: decoding it as UTF-8 produces mojibake rather than content.
+*/
+/** Application types whose payload is text. Mirrors the set the content-protection code
+*  treats as textual, plus the source and data formats this pipeline also accepts. */
+const TEXTUAL_APPLICATION_MIME_TYPES = new Set([
+	"application/json",
+	"application/javascript",
+	"application/sql",
+	"application/xml",
+	"application/x-yaml",
+	"application/yaml",
+	"application/csv",
+	"application/typescript",
+	"application/x-sh",
+	"application/vnd.coffeescript"
+]);
+function isNativelyReadableText(mimeType) {
+	const normalized = mimeType.split(";", 1)[0].trim().toLowerCase();
+	return normalized.startsWith("text/") || TEXTUAL_APPLICATION_MIME_TYPES.has(normalized) || normalized === "message/rfc822";
+}
+function hasTextExtractionPath(mimeType) {
+	return TEXT_RECOVERABLE_MIME_TYPES.some((pattern) => pattern.test(mimeType));
+}
+/**
+* Resolves the default file path destination for a given mime type.
+* Resolution chain: endpoint overrides -> endpoint fallback -> global overrides -> global fallback -> system defaults.
+*/
+function resolveDefaultLLMDeliveryPath(mimeType, endpointConfig, globalConfig, endpoint, useResponsesApi, sttConfigured) {
+	const wildcard = mimeType.split("/")[0] + "/*";
+	if (endpointConfig?.overrides) {
+		if (endpointConfig.overrides[mimeType]) return endpointConfig.overrides[mimeType];
+		if (endpointConfig.overrides[wildcard]) return endpointConfig.overrides[wildcard];
+	}
+	if (endpointConfig?.fallback) return endpointConfig.fallback;
+	if (globalConfig?.overrides) {
+		if (globalConfig.overrides[mimeType]) return globalConfig.overrides[mimeType];
+		if (globalConfig.overrides[wildcard]) return globalConfig.overrides[wildcard];
+	}
+	if (globalConfig?.fallback) return globalConfig.fallback;
+	const systemDefault = SYSTEM_LLM_DELIVERY_DEFAULTS.overrides[mimeType] ?? SYSTEM_LLM_DELIVERY_DEFAULTS.overrides[wildcard] ?? SYSTEM_LLM_DELIVERY_DEFAULTS.fallback;
+	/** Only the system default is capability-gated: an explicit config above is the
+	*  admin's decision. A known endpoint that cannot encode documents or media would
+	*  otherwise accept the upload and hand the model nothing at all. */
+	/** `agents` is a container, not a provider: it is what an upload reports when the
+	*  agent's real provider could not be resolved, as for ephemeral agents. A custom
+	*  endpoint name is likewise unresolvable here, since its real provider is chosen
+	*  at request time and is usually OpenAI- or Anthropic-compatible. Judging
+	*  capability from either would downgrade media the actual provider can deliver,
+	*  so an unresolved provider keeps the system default. */
+	const namedEndpoint = endpoint != null && endpoint !== "agents";
+	const providerKnown = namedEndpoint && require_data_service.isKnownProviderIdentifier(endpoint);
+	const isMedia = mimeType.startsWith("audio/") || mimeType.startsWith("video/");
+	const canRecoverText = (type) => type.startsWith("audio/") && sttConfigured === false ? false : hasTextExtractionPath(type);
+	if (systemDefault === "provider" && (isMedia ? namedEndpoint : providerKnown) && !isProviderCapable(mimeType, endpoint, useResponsesApi)) return canRecoverText(mimeType) ? "text" : "none";
+	/** Bedrock's Converse document path natively accepts more than PDF, so on that
+	*  endpoint its document types belong on the provider path rather than being
+	*  extracted, which would drop non-text content and layout. */
+	if (systemDefault !== "provider" && endpoint === "bedrock" && require_data_service.isBedrockDocumentType(mimeType)) return "provider";
+	if (systemDefault === "text" && !canRecoverText(mimeType)) return "none";
+	return systemDefault;
+}
+/**
+* Delivery path for an upload that named no tool resource. The legacy chooser makes the
+* destination explicit, so nothing is inferred there.
+*/
+function resolveDefaultUploadLLMDeliveryPath({ mimeType, endpointConfig, fileConfig, endpoint, useResponsesApi, sttConfigured }) {
+	if (endpointConfig?.legacyFileUploadUX === true) return "provider";
+	return resolveDefaultLLMDeliveryPath(mimeType, endpointConfig?.defaultLLMDeliveryPath, fileConfig?.defaultLLMDeliveryPath, endpoint, useResponsesApi, sttConfigured);
+}
+/** Delivery path for an upload, honoring an explicitly chosen tool resource. */
+function resolveUploadLLMDeliveryPath({ toolResource, mimeType, endpointConfig, fileConfig, endpoint, useResponsesApi, sttConfigured }) {
+	if (toolResource === "context" || toolResource === "ocr") return "text";
+	if (toolResource === "file_search" || toolResource === "execute_code") return "none";
+	return resolveDefaultUploadLLMDeliveryPath({
+		mimeType,
+		endpointConfig,
+		fileConfig,
+		endpoint,
+		useResponsesApi,
+		sttConfigured
+	});
+}
+/**
+* Whether a file tool can do anything with this type. `file_search` indexes extracted
+* text, so it needs a type some step can turn into text and cannot use media, whose
+* extraction paths are OCR and speech rather than the vector store. Code execution is
+* judged by the list the client offers it from. Shared by upload-time selection and
+* deferred provisioning so the two cannot queue a file the other would refuse.
+*/
+function canToolResourceConsume(toolResource, mimeType) {
+	if (toolResource === "file_search") return !mimeType.startsWith("image") && !mimeType.startsWith("audio") && !mimeType.startsWith("video") && (hasTextExtractionPath(mimeType) || matchesMimeList(mimeType, require_data_service.retrievalMimeTypes));
+	if (toolResource === "execute_code") return matchesMimeList(mimeType, require_data_service.codeInterpreterMimeTypes);
+	return true;
+}
+const matchesMimeList = (mimeType, patterns) => patterns.some((pattern) => pattern.test(mimeType));
+/**
+* Where a unified upload will end up, and whether it can be accepted at all.
+*
+* An upload has to be readable by something: the model, an extraction step, or a file
+* tool. A permanent one has to land on an agent resource too, or storing it succeeds
+* while leaving the agent no reference to it. Both outcomes are decided here rather than
+* discovered later, so a request that would change nothing is refused with a reason.
+*
+* `agentTools` is undefined when no agent record backs the upload, as for an ephemeral
+* agent that exists only for the request. An unknown tool set is not judged.
+*/
+function resolveUploadDestination(params) {
+	const { toolResource, deliveryPath, mimeType, agentTools, hasAgent, isMessageAttachment, allowUnknownMessageConsumer = false, contextEnabled } = params;
+	const refusesContext = (resource) => resource === "context" && hasAgent && !isMessageAttachment && contextEnabled === false;
+	if (toolResource) {
+		const resolved = toolResource === "ocr" ? "context" : toolResource;
+		return refusesContext(resolved) ? { rejection: "context-disabled" } : { toolResource: resolved };
+	}
+	if (deliveryPath === "text") return refusesContext("context") ? { rejection: "context-disabled" } : { toolResource: "context" };
+	const consumingTool = agentTools?.find((tool) => (tool === "execute_code" || tool === "file_search") && canToolResourceConsume(tool, mimeType));
+	if (deliveryPath === "none" && consumingTool) return { toolResource: consumingTool };
+	if (hasAgent && !isMessageAttachment) return { rejection: "no-agent-resource" };
+	if (deliveryPath === "none" && (!isMessageAttachment || !allowUnknownMessageConsumer)) return { rejection: "no-consumer" };
+	return {};
+}
+//#endregion
 //#region src/messages.ts
+/** A generated reasoning title describes the text as it existed at generation time.
+*  Any manual edit or merge into a different reasoning step invalidates the entire
+*  title revision domain while preserving unrelated content metadata. */
+function stripReasoningLabelMetadata(part) {
+	if (part.type !== "think") return part;
+	const { reasoning_label: _label, reasoning_label_step_id: _stepId, reasoning_label_attempts: _attempts, reasoning_label_submitted_chars: _submittedChars, reasoning_label_revision: _revision, reasoning_label_status: _status, ...unlabeledPart } = part;
+	return unlabeledPart;
+}
+const treeCache = /* @__PURE__ */ new WeakMap();
 /**
 * Builds the render tree from the flat messages array. Order-robust: live
 * stream/steer/preempt cache writes can momentarily place a child before its
@@ -1266,6 +1636,11 @@ function mapGroupToAzureConfig({ groupName, groupMap }) {
 */
 function buildTree({ messages, fileMap }) {
 	if (messages === null) return null;
+	const cached = treeCache.get(messages);
+	if (cached) {
+		if (fileMap == null && cached.bare) return cached.bare;
+		if (fileMap != null && cached.fileMap === fileMap && cached.hydrated) return cached.hydrated;
+	}
 	const messageMap = {};
 	const orderedMessages = [];
 	const rootMessages = [];
@@ -1319,7 +1694,129 @@ function buildTree({ messages, fileMap }) {
 		rootMessages.push(extendedMessage);
 		assignDepths(extendedMessage);
 	}
-	return rootMessages;
+	const tree = rootMessages;
+	const entry = cached ?? {};
+	if (fileMap == null) entry.bare = tree;
+	else {
+		entry.fileMap = fileMap;
+		entry.hydrated = tree;
+	}
+	if (!cached) treeCache.set(messages, entry);
+	return tree;
+}
+/**
+* Memoizes a messages array's id index. Every row that needs to look another
+* message up (the hover controls resolving the turn a rerun would replay) would
+* otherwise scan the whole array, which is quadratic in the conversation. A
+* cache write replaces the array, so the index dies with the array it indexes
+* and can never answer from stale rows.
+*/
+const indexCache = /* @__PURE__ */ new WeakMap();
+/** The message with this id, resolved through the array's memoized index. */
+function findMessageById(messages, messageId) {
+	if (messages == null || messageId == null) return;
+	let index = indexCache.get(messages);
+	if (index == null) {
+		index = /* @__PURE__ */ new Map();
+		for (const message of messages) if (message?.messageId != null && !index.has(message.messageId)) index.set(message.messageId, message);
+		indexCache.set(messages, index);
+	}
+	return index.get(messageId);
+}
+/**
+* True when a turn carries the marker the server stamps on a manual compaction:
+* `markCompactionSummary` sets `initiatedBy: 'user'` on the summary a Compact
+* action produced, and nothing else writes it, so an automatic summary detour is
+* not one. This is the compaction's own identity, independent of where it hangs:
+* Compact runs on whatever leaf the branch ends with, so its response can parent
+* onto a user message as easily as onto the answer it summarized. Redoing one is
+* the context indicator's Compact action, never a rerun of the turn behind it.
+*/
+function isUserInitiatedCompaction(message) {
+	const content = message?.content;
+	if (!Array.isArray(content)) return false;
+	return content.some((part) => part?.type === "summary" && part.initiatedBy === "user");
+}
+/**
+* True when a message is a finished manual compaction: every content part is a
+* summary and at least one of them carries text. A part that is still streaming
+* or that failed contributes no text of its own, so an interrupted compaction
+* can be retried.
+*/
+function isCompactedLeaf(message) {
+	const content = message?.content;
+	if (!Array.isArray(content) || content.length === 0) return false;
+	let usable = false;
+	for (const part of content) {
+		if (part?.type !== "summary") return false;
+		if (part.summarizing === true || part.failed === true) continue;
+		const hasText = (part.content ?? []).some((block) => typeof block?.text === "string" && block.text.trim().length > 0);
+		usable = usable || hasText;
+	}
+	return usable;
+}
+//#endregion
+//#region src/errors.ts
+const TOOL_CALL_ERROR_PREFIX = /^Error:\s*(?:\[[^\]]*\]\s*)*tool call failed:\s*/i;
+function hasToolCallErrorPrefix(text) {
+	return TOOL_CALL_ERROR_PREFIX.test(text);
+}
+function stripToolCallErrorPrefix(text) {
+	return text.replace(TOOL_CALL_ERROR_PREFIX, "");
+}
+//#endregion
+//#region src/runSteps.ts
+/**
+* Below this, a duration is noise rather than information: sub-second tool
+* calls are the common case, and labelling every one of them `· 0.3s` adds a
+* moving number to the end of most cards without telling the reader anything
+* they could act on. Callers use {@link isReportableRunStepDuration} rather
+* than comparing against this directly.
+*/
+const MIN_REPORTABLE_RUN_STEP_DURATION_MS = 1e3;
+/**
+* Wall-clock duration of a run step, derived from the terminal
+* `on_run_step_closed` event.
+*
+* Returns `undefined` rather than a fallback whenever the value would be a
+* guess, because a wrong duration is worse than an absent one — an absent one
+* renders nothing, a wrong one is indistinguishable from a real measurement:
+*
+* - `created_at` is optional on the event; emitters that do not know when the
+*   step opened cannot have their duration inferred from anything else.
+* - A negative result means the two timestamps came from clocks that disagree.
+*   That is not hypothetical: since `@librechat/agents` v3.6.0 a step can be
+*   opened in one process and closed in another after a checkpoint resume, so
+*   the two stamps can legitimately originate on different machines.
+* - Non-finite input is treated as absent instead of propagating `NaN` into
+*   rendering.
+*
+* Known limits, accepted rather than guessed at: only the negative direction
+* of clock skew is detectable from a single stamp pair — positive skew
+* inflates the result and cannot be distinguished from a genuinely long
+* step. And the value is wall-clock elapsed between open and close, so a
+* step held open across a suspension (a checkpoint resume, a HITL approval
+* wait) includes that held-open time. Both are properties of the only data
+* available, not derivation bugs.
+*/
+function getRunStepDurationMs(closed) {
+	const { created_at: createdAt, closed_at: closedAt } = closed;
+	if (typeof createdAt !== "number" || typeof closedAt !== "number") return;
+	if (!Number.isFinite(createdAt) || !Number.isFinite(closedAt)) return;
+	const durationMs = closedAt - createdAt;
+	return durationMs >= 0 ? durationMs : void 0;
+}
+/**
+* Whether a derived duration is worth showing to the reader.
+*
+* This is a presentation judgment, so it belongs at render time only. The
+* stamp sites persist the raw {@link getRunStepDurationMs} value instead of
+* pre-filtering through this — thresholding at write time would bake a
+* display rule into stored data, making "fast" indistinguishable from "not
+* derivable" and unrecoverable if the rule ever changes.
+*/
+function isReportableRunStepDuration(durationMs) {
+	return typeof durationMs === "number" && durationMs >= 1e3;
 }
 //#endregion
 //#region src/artifacts.ts
@@ -4492,6 +4989,10 @@ let PermissionTypes = /* @__PURE__ */ function(PermissionTypes) {
 	* Type for Shared Link Permissions
 	*/
 	PermissionTypes["SHARED_LINKS"] = "SHARED_LINKS";
+	/**
+	* Type for Scheduled Chats Permissions
+	*/
+	PermissionTypes["SCHEDULES"] = "SCHEDULES";
 	return PermissionTypes;
 }({});
 /**
@@ -4515,11 +5016,20 @@ const PERMISSION_TYPE_INTERFACE_FIELDS = {
 	["MCP_SERVERS"]: "mcpServers",
 	["REMOTE_AGENTS"]: "remoteAgents",
 	["SKILLS"]: "skills",
-	["SHARED_LINKS"]: "sharedLinks"
+	["SHARED_LINKS"]: "sharedLinks",
+	["SCHEDULES"]: "schedules"
 };
 /** Set of interface config field names that correspond to role permissions. */
 const INTERFACE_PERMISSION_FIELDS = new Set(Object.values(PERMISSION_TYPE_INTERFACE_FIELDS));
 /**
+* Interface fields that seed a permission (use/create) BUT also carry runtime
+* config that must survive DB/tenant/user overrides. For these, override
+* sanitizers strip only the permission sub-keys (use/create) from the object
+* form and PRESERVE the boolean form — for `schedules`, `interface.schedules: false`
+* is the runtime feature disable that `getLimits` reads, not a permission toggle.
+*/
+const RUNTIME_CONFIG_INTERFACE_FIELDS = new Set(["schedules"]);
+/**
 * YAML sub-keys within composite interface permission fields that map to permission bits.
 * When an interface permission field is an object, only these sub-keys are stripped from
 * DB overrides — other sub-keys (like `placeholder`, `trustCheckbox`) are UI-only and pass through.
@@ -4620,6 +5130,10 @@ const skillPermissionsSchema = zod.z.object({
 	["SHARE"]: zod.z.boolean().default(false),
 	["SHARE_PUBLIC"]: zod.z.boolean().default(false)
 });
+const schedulesPermissionsSchema = zod.z.object({
+	["USE"]: zod.z.boolean().default(true),
+	["CREATE"]: zod.z.boolean().default(true)
+});
 const sharedLinksPermissionsSchema = zod.z.object({
 	["CREATE"]: zod.z.boolean().default(true),
 	["SHARE"]: zod.z.boolean().default(true),
@@ -4641,7 +5155,8 @@ const permissionsSchema = zod.z.object({
 	["MCP_SERVERS"]: mcpServersPermissionsSchema,
 	["REMOTE_AGENTS"]: remoteAgentsPermissionsSchema,
 	["SKILLS"]: skillPermissionsSchema,
-	["SHARED_LINKS"]: sharedLinksPermissionsSchema
+	["SHARED_LINKS"]: sharedLinksPermissionsSchema,
+	["SCHEDULES"]: schedulesPermissionsSchema
 });
 //#endregion
 //#region src/roles.ts
@@ -4722,6 +5237,10 @@ const defaultRolesSchema = zod.z.object({
 				["CREATE"]: zod.z.boolean().default(true),
 				["SHARE"]: zod.z.boolean().default(true),
 				["SHARE_PUBLIC"]: zod.z.boolean().default(true)
+			}),
+			["SCHEDULES"]: schedulesPermissionsSchema.extend({
+				["USE"]: zod.z.boolean().default(true),
+				["CREATE"]: zod.z.boolean().default(true)
 			})
 		})
 	}),
@@ -4795,6 +5314,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	},
@@ -4850,6 +5373,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	}
@@ -4869,6 +5396,337 @@ let InvocationMode = /* @__PURE__ */ function(InvocationMode) {
 	return InvocationMode;
 }({});
 //#endregion
+//#region src/types/schedules.ts
+/** Cadences the dialog builds from structured pickers (hour, minute, weekday). */
+const scheduleStructuredFrequencies = [
+	"hourly",
+	"daily",
+	"weekdays",
+	"weekly"
+];
+const scheduleFrequencies = [...scheduleStructuredFrequencies, "cron"];
+/** Bounds a stored expression. Generous for five fields, because each one can hold a
+*  list: an every-minute-of-the-hour cadence spelled out runs past two hundred chars. */
+const SCHEDULE_CRON_MAX_LENGTH = 256;
+const scheduleTargets = ["new"];
+const structuredCadenceSchema = zod.z.object({
+	frequency: zod.z.enum(scheduleStructuredFrequencies),
+	hour: zod.z.number().int().min(0).max(23),
+	minute: zod.z.number().int().min(0).max(59),
+	daysOfWeek: zod.z.array(zod.z.number().int().min(0).max(6)).min(1).max(7).transform((days) => Array.from(new Set(days))).optional()
+});
+/**
+* A raw cron expression carries its own hour and minute, so it cannot share the
+* structured shape: there is no single `hour` for `0 9,17 * * 1-5`. Syntax is
+* validated server-side by croner, the same parser the engine fires from, rather
+* than by a regex that would accept patterns croner then rejects at fire time.
+*/
+const cronCadenceSchema = zod.z.object({
+	frequency: zod.z.literal("cron"),
+	expression: zod.z.string().trim().min(1).max(256)
+});
+const scheduleCadenceSchema = zod.z.discriminatedUnion("frequency", [structuredCadenceSchema, cronCadenceSchema]);
+const isCronCadence = (cadence) => cadence.frequency === "cron";
+const createSchedulePayloadSchema = zod.z.object({
+	name: zod.z.string().trim().min(1).max(256),
+	prompt: zod.z.string().trim().min(1).max(32e3),
+	agent_id: zod.z.string().trim().min(1),
+	cadence: scheduleCadenceSchema,
+	timezone: zod.z.string().min(1),
+	target: zod.z.enum(scheduleTargets).default("new"),
+	file_ids: zod.z.array(zod.z.string()).max(10).transform((ids) => Array.from(new Set(ids))).optional(),
+	/**
+	* Chat project each run's conversation is filed under. `null` clears the scope.
+	* Ownership is checked server-side at write time and again at every fire, so a
+	* deleted project disables the schedule instead of silently filing runs loose.
+	*/
+	chatProjectId: zod.z.string().trim().min(1).nullable().optional(),
+	enabled: zod.z.boolean().default(true),
+	/**
+	* Client-generated key making creation idempotent across retries. Creation commits
+	* the row and arms it in two writes, so a failure between them leaves the client
+	* unable to tell whether anything persisted; retrying blind can produce two recurring
+	* schedules. A retry carrying the same key resolves to the original row instead.
+	* REQUIRED: an optional key preserves the keyless duplicate path for any client
+	* that omits it, which is exactly the failure the key exists to close.
+	*/
+	clientRequestId: zod.z.string().trim().min(1).max(128)
+});
+/** Idempotency is a property of the CREATE attempt, not of the schedule's config. */
+const updateSchedulePayloadSchema = createSchedulePayloadSchema.omit({ clientRequestId: true }).partial().extend({ 
+/**
+* The configRevision the client's edit was computed from (captured when the
+* dialog opened). The server fences the update on it, so a concurrent edit
+* from another tab answers 409 instead of being silently overwritten by a
+* payload rebuilt from a stale snapshot (cadence is sent whole, so the
+* server-side fresh-read fence alone cannot detect this).
+*/
+expectedConfigRevision: zod.z.number().int().min(0).optional() });
+/** Only structured schedule preflight failures may request immediate suspension. */
+function getScheduleMCPDisabledReason(outcomes) {
+	const statuses = new Set(outcomes?.map((outcome) => outcome.status));
+	if (statuses.has("mcp_permission_denied")) return "mcp_permission_denied";
+	if (statuses.has("mcp_configuration_missing")) return "mcp_configuration_missing";
+	if (statuses.has("mcp_reauth_required")) return "mcp_reauth_required";
+}
+const scheduleMCPOutcomeSchema = zod.z.object({
+	server: zod.z.string(),
+	/** Agent whose selected tool requires this server. Used to open the correct
+	* recovery chat when the requirement belongs to a handoff or subagent. */
+	agentId: zod.z.string().optional(),
+	status: zod.z.enum([
+		"ready",
+		"mcp_reauth_required",
+		"mcp_configuration_missing",
+		"mcp_permission_denied",
+		"mcp_unavailable"
+	])
+});
+function readScheduleMCPOutcomes(error) {
+	if (!error || !/^mcp_(reauth_required|configuration_missing|permission_denied|unavailable): \[/.test(error)) return [];
+	try {
+		const result = scheduleMCPOutcomeSchema.array().safeParse(JSON.parse(error.slice(error.indexOf(": ") + 2)));
+		return result.success ? result.data : [];
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/cadence.ts
+/** Mirrors the server default when a weekly cadence omits `daysOfWeek`. */
+const WEEKLY_DEFAULT_DAY = 1;
+/**
+* Minute, hour, day of month, month, day of week. croner also reads a six-field form
+* carrying seconds and a seven-field form that pins a year, and both are refused.
+* Seconds would promise a precision the runtime does not keep: the engine polls on a
+* thirty-second tick and offsets each schedule by up to two minutes of jitter. A pinned
+* year makes a cadence that runs out, and every caller here treats "no next occurrence"
+* as a cadence it cannot read.
+*/
+const CRON_FIELD_COUNT = 5;
+/**
+* Spring-forward compresses consecutive wall-clock occurrences, so the ENFORCEABLE
+* minimum for day-and-longer gaps is the nominal gap minus the largest real-world
+* transition: two hours (Antarctica/Troll; every other zone shifts at most one).
+* A floor set exactly at the nominal value would otherwise admit a schedule that
+* genuinely violates it once a year. Hourly gaps are unaffected (the skipped hours
+* lengthen, never shorten, the gap between occurrences).
+*/
+const DST_COMPRESSION_MINUTES = 120;
+/**
+* Occurrences sampled when measuring a cron expression's tightest gap. The floor
+* exists to reject expressions that fire too OFTEN, and a dense pattern reveals
+* its short gap within the first few occurrences, so a small window answers the
+* question this guards. Known limit: this is a bounded probe, not the exhaustive
+* proof the structured formulas give. An expression that is sparse for the next
+* `CRON_PROBE_OCCURRENCES` runs and dense later would pass here and be caught by
+* the fire-time recheck instead.
+*/
+const CRON_PROBE_OCCURRENCES = 32;
+/** Enough to span four nominal gaps from an anchor two gaps before a transition,
+*  which is what guarantees the straddling pair falls inside the window. */
+const TRANSITION_PROBE_OCCURRENCES = 5;
+/**
+* Compiles a cadence to the cron expression the engine fires from. Shared rather
+* than server-owned because the dialog previews the next runs, validates the
+* interval floor, and disables its own submit from these same functions: a second
+* client-side implementation would drift and either show run times the schedule
+* does not keep or accept a cadence the server then rejects.
+*/
+function cadenceToCron(cadence) {
+	if (cadence.frequency === "cron") return cadence.expression;
+	const { frequency, hour, minute } = cadence;
+	if (frequency === "hourly") return `${minute} * * * *`;
+	if (frequency === "daily") return `${minute} ${hour} * * *`;
+	if (frequency === "weekdays") return `${minute} ${hour} * * 1-5`;
+	return `${minute} ${hour} * * ${[...cadence.daysOfWeek?.length ? cadence.daysOfWeek : [WEEKLY_DEFAULT_DAY]].sort((a, b) => a - b).join(",")}`;
+}
+/**
+* Everything `cronCadenceSchema` will accept: exactly five fields, within the length
+* the schema stores, and actually matching at some point. croner accepts syntactically
+* valid patterns that can never match (`0 0 30 2 *`), and those would arm a schedule
+* that never fires. Validated with croner rather than a regex, because a regex would
+* accept patterns croner then rejects at fire time.
+*
+* A five-field expression that matches at all matches forever, which is what lets every
+* caller keep reading "no next occurrence" as "this cadence is unreadable".
+*/
+function isValidCronExpression(expression, timezone) {
+	const trimmed = expression.trim();
+	if (trimmed.length > 256) return false;
+	if (trimmed.split(/\s+/).length !== CRON_FIELD_COUNT) return false;
+	try {
+		return new croner.Cron(trimmed, {
+			timezone,
+			paused: true
+		}).nextRun() != null;
+	} catch {
+		return false;
+	}
+}
+/**
+* The next occurrences the engine would fire. Server-side jitter (up to two
+* minutes) is deliberately not modelled: it is keyed off a schedule id that does
+* not exist yet at create time, and showing 9:01 for a 9:00 schedule reads as a bug.
+*/
+function nextRunInstants(cadence, timezone, count) {
+	try {
+		const runs = new croner.Cron(cadenceToCron(cadence), {
+			timezone,
+			paused: true
+		}).nextRuns(count);
+		return runs.filter((run, index) => index === 0 || run.getTime() !== runs[index - 1].getTime());
+	} catch {
+		return [];
+	}
+}
+const MINUTE_MS = 6e4;
+const DAY_MS = 1440 * MINUTE_MS;
+/** A year and a bit, so a zone with a single yearly transition always shows one. */
+const TRANSITION_SEARCH_DAYS = 400;
+const offsetFormatters = /* @__PURE__ */ new Map();
+/** Minutes east of UTC in `zone` at `instant`, read back from the wall clock the
+*  zone renders. The only way to observe a zone's offset without a tz database. */
+function zoneOffsetMinutes(zone, instant) {
+	let formatter = offsetFormatters.get(zone);
+	if (formatter == null) {
+		formatter = new Intl.DateTimeFormat("en-US", {
+			timeZone: zone,
+			hourCycle: "h23",
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit"
+		});
+		offsetFormatters.set(zone, formatter);
+	}
+	const parts = {};
+	for (const part of formatter.formatToParts(instant)) parts[part.type] = part.value;
+	const wallClock = Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day), Number(parts.hour), Number(parts.minute), Number(parts.second));
+	return Math.round((wallClock - instant.getTime()) / MINUTE_MS);
+}
+/** Zone transitions are asked for once per fire, and the scan below costs ~10ms.
+*  Keyed by day because that is how far the answer stays put as the window slides,
+*  and cleared wholesale at the cap so a long-lived worker cannot accumulate an
+*  entry per zone per day forever. */
+const transitionCache = /* @__PURE__ */ new Map();
+const TRANSITION_CACHE_MAX = 512;
+/**
+* Every instant `zone` changes its UTC offset within the search window; empty for a
+* fixed-offset zone. Both directions matter and only one of them shortens anything,
+* so taking just the next one would usually find the harmless fall-back and miss the
+* spring-forward six months behind it. Bracketed a day at a time, bisected to the
+* minute.
+*/
+function offsetChanges(zone, from) {
+	const day = Math.floor(from.getTime() / DAY_MS);
+	const cacheKey = `${zone}:${day}`;
+	const cached = transitionCache.get(cacheKey);
+	if (cached != null) return cached;
+	const changes = [];
+	const start = /* @__PURE__ */ new Date((day - 1) * DAY_MS);
+	let low = start.getTime();
+	let baseOffset = zoneOffsetMinutes(zone, start);
+	const end = low + TRANSITION_SEARCH_DAYS * DAY_MS;
+	for (let probe = low + DAY_MS; probe <= end; probe += DAY_MS) {
+		const offset = zoneOffsetMinutes(zone, new Date(probe));
+		if (offset !== baseOffset) {
+			let high = probe;
+			let bracket = low;
+			while (high - bracket > MINUTE_MS) {
+				const mid = bracket + Math.floor((high - bracket) / 2);
+				if (zoneOffsetMinutes(zone, new Date(mid)) === baseOffset) bracket = mid;
+				else high = mid;
+			}
+			changes.push(new Date(high));
+			baseOffset = offset;
+		}
+		low = probe;
+	}
+	if (transitionCache.size >= TRANSITION_CACHE_MAX) transitionCache.clear();
+	transitionCache.set(cacheKey, changes);
+	return changes;
+}
+function runsAfter(expression, from, zone, occurrences = CRON_PROBE_OCCURRENCES) {
+	return new croner.Cron(expression, {
+		timezone: zone,
+		paused: true
+	}).nextRuns(occurrences, from);
+}
+/** Tightest gap, in minutes, across `runs`; null when there is no pair to measure. */
+function minGapMinutes(runs) {
+	if (runs.length < 2) return null;
+	let minGapMs = Number.MAX_SAFE_INTEGER;
+	for (let i = 1; i < runs.length; i++) {
+		const gapMs = runs[i].getTime() - runs[i - 1].getTime();
+		if (gapMs <= 0) continue;
+		minGapMs = Math.min(minGapMs, gapMs);
+	}
+	if (minGapMs === Number.MAX_SAFE_INTEGER) return null;
+	return Math.floor(minGapMs / MINUTE_MS);
+}
+function probeMinGapMinutes(expression, zone, from, occurrences = CRON_PROBE_OCCURRENCES) {
+	return minGapMinutes(runsAfter(expression, from, zone, occurrences));
+}
+/**
+* Smallest gap in minutes between occurrences. Returns 0 for an unparseable or
+* never-matching expression so every floor rejects it, failing closed rather than
+* admitting an expression the engine cannot fire.
+*
+* Measured twice, and the smaller wins:
+*
+* 1. Nominal, probed in UTC, then discounted by the same worst-case DST allowance
+*    the structured branches assume. This keeps `0 9 * * *` reporting exactly what
+*    the Daily preset reports, so the same schedule cannot be admitted in one form
+*    and rejected in the other.
+* 2. Real elapsed time in the schedule's own zone, across each of that zone's
+*    transitions. Spring-forward compresses a gap that straddles one
+*    (`0 0,12 * * *` in America/New_York is 11 hours that day, not 12), and step 1
+*    only discounts gaps of a day or more, so a subdaily gap needs measuring rather
+*    than estimating. Anchoring at the transition is what makes a bounded probe see
+*    it at all: from today it is usually months outside any reasonable window.
+*/
+function cronIntervalMinutes(expression, timezone) {
+	try {
+		const now = /* @__PURE__ */ new Date();
+		const nominal = probeMinGapMinutes(expression, "UTC", now);
+		if (nominal == null) return 0;
+		const estimate = nominal < 1440 ? nominal : Math.max(0, nominal - DST_COMPRESSION_MINUTES);
+		if (timezone == null || estimate === 0) return estimate;
+		const anchorBackMs = 2 * Math.max(nominal, 1) * MINUTE_MS;
+		let smallest = estimate;
+		for (const transition of offsetChanges(timezone, now)) {
+			const measured = probeMinGapMinutes(expression, timezone, new Date(Math.max(now.getTime(), transition.getTime() - anchorBackMs)), TRANSITION_PROBE_OCCURRENCES);
+			if (measured != null) smallest = Math.min(smallest, measured);
+		}
+		return smallest;
+	} catch {
+		return 0;
+	}
+}
+/**
+* Minimum minutes between occurrences, for the admin interval floor. `timezone` is
+* the schedule's own; passing it lets the cron branch measure a DST-compressed gap
+* instead of estimating one. The structured branches are zone-independent: their
+* formulas already carry the worst-case allowance.
+*/
+function cadenceIntervalMinutes(cadence, timezone) {
+	if (isCronCadence(cadence)) return cronIntervalMinutes(cadence.expression, timezone);
+	if (cadence.frequency === "hourly") return 60;
+	if (cadence.frequency === "daily" || cadence.frequency === "weekdays") return 1440 - DST_COMPRESSION_MINUTES;
+	const days = cadence.daysOfWeek?.length ? Array.from(new Set(cadence.daysOfWeek)) : [WEEKLY_DEFAULT_DAY];
+	if (days.length <= 1) return 10080 - DST_COMPRESSION_MINUTES;
+	const sorted = [...days].sort((a, b) => a - b);
+	let minGapDays = 7;
+	for (let i = 0; i < sorted.length; i++) {
+		const gap = i + 1 < sorted.length ? sorted[i + 1] - sorted[i] : 7 - sorted[i] + sorted[0];
+		minGapDays = Math.min(minGapDays, gap);
+	}
+	return minGapDays * 24 * 60 - DST_COMPRESSION_MINUTES;
+}
+//#endregion
 //#region src/types/skills.ts
 /**
 * Shared skill validation constants — the single source of truth for name,
@@ -4901,6 +5759,252 @@ let DATE_RANGE = /* @__PURE__ */ function(DATE_RANGE) {
 	return DATE_RANGE;
 }({});
 //#endregion
+//#region src/types/insights.ts
+const INSIGHTS_MAX_RANGE_DAYS = 30;
+const INSIGHTS_SEARCH_MIN_LENGTH = 3;
+const INSIGHTS_SEARCH_MAX_LENGTH = 200;
+const INSIGHTS_AGENT_ID_MAX_LENGTH = 256;
+//#endregion
+//#region src/types/traces.ts
+const TRACE_CURSOR_MAX_LENGTH = 4096;
+const TRACE_SOURCE_ID_MAX_LENGTH = 128;
+const TRACE_RECORD_ID_MAX_LENGTH = 256;
+//#endregion
+//#region src/types/queuedTurns.ts
+const agentQueuedTurnStatuses = [
+	"queued",
+	"claimed",
+	"admitted",
+	"cancelled",
+	"dead"
+];
+const agentQueuedTurnDurability = ["process_local", "durable"];
+const agentQueuedTurnFileRefSchema = zod.z.object({
+	file_id: zod.z.string().trim().min(1),
+	type: zod.z.string().optional(),
+	filepath: zod.z.string().optional(),
+	filename: zod.z.string().optional(),
+	height: zod.z.number().optional(),
+	width: zod.z.number().optional(),
+	bytes: zod.z.number().nonnegative().optional()
+});
+const enqueueAgentQueuedTurnSchema = zod.z.object({
+	conversationId: zod.z.string().trim().min(1),
+	parentMessageId: zod.z.string().trim().min(1),
+	clientRequestId: zod.z.string().trim().min(1).max(128),
+	text: zod.z.string(),
+	files: zod.z.array(agentQueuedTurnFileRefSchema).optional(),
+	quotes: zod.z.array(zod.z.string()).optional(),
+	manualSkills: zod.z.array(zod.z.string().trim().min(1)).optional(),
+	priority: zod.z.boolean().optional(),
+	expectedPredecessorCreatedAt: zod.z.number().int().nonnegative().optional()
+});
+const listAgentQueuedTurnsSchema = zod.z.object({
+	conversationId: zod.z.string().trim().min(1),
+	clientRequestIds: zod.z.array(zod.z.string().trim().min(1).max(128)).max(100).transform((ids) => Array.from(new Set(ids))).optional()
+});
+const cancelAgentQueuedTurnSchema = zod.z.object({ queuedTurnId: zod.z.string().trim().min(1) });
+const agentQueuedTurnReceiptSchema = enqueueAgentQueuedTurnSchema.extend({
+	queuedTurnId: zod.z.string().trim().min(1),
+	status: zod.z.enum(agentQueuedTurnStatuses),
+	/** Effective generation boundary consumed by an admitted turn. This can
+	* advance beyond the originally captured root as queued turns chain. */
+	effectivePredecessorCreatedAt: zod.z.number().int().nonnegative().optional(),
+	/** Explicitly proves that this admission consumed no predecessor boundary. */
+	rootPredecessor: zod.z.literal(true).optional(),
+	position: zod.z.number().int().nonnegative().optional(),
+	/** Immutable queue sequence retained as `revision` for wire compatibility. */
+	revision: zod.z.number().int().nonnegative(),
+	failure: zod.z.object({
+		code: zod.z.string().trim().min(1).max(128),
+		message: zod.z.string().max(2048).optional()
+	}).optional(),
+	createdAt: zod.z.string(),
+	updatedAt: zod.z.string()
+});
+const agentQueuedTurnCapabilitySchema = zod.z.discriminatedUnion("supported", [zod.z.object({ supported: zod.z.literal(false) }), zod.z.object({
+	supported: zod.z.literal(true),
+	durability: zod.z.enum(agentQueuedTurnDurability)
+})]);
+const enqueueAgentQueuedTurnResponseSchema = zod.z.object({
+	receipt: agentQueuedTurnReceiptSchema,
+	capability: agentQueuedTurnCapabilitySchema
+});
+const listAgentQueuedTurnsResponseSchema = zod.z.object({
+	queuedTurns: zod.z.array(agentQueuedTurnReceiptSchema),
+	capability: agentQueuedTurnCapabilitySchema,
+	revision: zod.z.number().int().nonnegative()
+});
+const cancelAgentQueuedTurnResponseSchema = zod.z.object({ receipt: agentQueuedTurnReceiptSchema });
+//#endregion
+//#region src/providers.ts
+/** Canonical provider identity used for branding across client and server. */
+let ProviderId = /* @__PURE__ */ function(ProviderId) {
+	ProviderId["openai"] = "openai";
+	ProviderId["anthropic"] = "anthropic";
+	ProviderId["google"] = "google";
+	ProviderId["azure"] = "azure";
+	ProviderId["bedrock"] = "bedrock";
+	ProviderId["xai"] = "xai";
+	ProviderId["moonshot"] = "moonshot";
+	ProviderId["anyscale"] = "anyscale";
+	ProviderId["apipie"] = "apipie";
+	ProviderId["cohere"] = "cohere";
+	ProviderId["deepseek"] = "deepseek";
+	ProviderId["fireworks"] = "fireworks";
+	ProviderId["groq"] = "groq";
+	ProviderId["helicone"] = "helicone";
+	ProviderId["huggingface"] = "huggingface";
+	ProviderId["lemonade"] = "lemonade";
+	ProviderId["mistral"] = "mistral";
+	ProviderId["mlx"] = "mlx";
+	ProviderId["ollama"] = "ollama";
+	ProviderId["openrouter"] = "openrouter";
+	ProviderId["perplexity"] = "perplexity";
+	ProviderId["qwen"] = "qwen";
+	ProviderId["shuttleai"] = "shuttleai";
+	ProviderId["together"] = "together";
+	ProviderId["unify"] = "unify";
+	ProviderId["vercel"] = "vercel";
+	return ProviderId;
+}({});
+const endpointToProvider = {
+	["openAI"]: "openai",
+	["azureOpenAI"]: "azure",
+	["anthropic"]: "anthropic",
+	["google"]: "google",
+	["bedrock"]: "bedrock"
+};
+const knownEndpointToProvider = {
+	["anyscale"]: "anyscale",
+	["apipie"]: "apipie",
+	["cohere"]: "cohere",
+	["fireworks"]: "fireworks",
+	["deepseek"]: "deepseek",
+	["moonshot"]: "moonshot",
+	["groq"]: "groq",
+	["helicone"]: "helicone",
+	["huggingface"]: "huggingface",
+	["lemonade"]: "lemonade",
+	["mistral"]: "mistral",
+	["mlx"]: "mlx",
+	["ollama"]: "ollama",
+	["openrouter"]: "openrouter",
+	["perplexity"]: "perplexity",
+	["shuttleai"]: "shuttleai",
+	["together.ai"]: "together",
+	["unify"]: "unify",
+	["vercel"]: "vercel",
+	["xai"]: "xai"
+};
+const providerAliases = {
+	chatgpt: "openai",
+	gpt: "openai",
+	azureopenai: "azure",
+	claude: "anthropic",
+	gemini: "google",
+	gemma: "google",
+	vertex: "google",
+	vertexai: "google",
+	palm: "google",
+	awsbedrock: "bedrock",
+	grok: "xai",
+	kimi: "moonshot",
+	moonshotai: "moonshot",
+	amdlemonade: "lemonade",
+	lemonadeserver: "lemonade",
+	mistralai: "mistral",
+	togetherai: "together"
+};
+const modelCatalogAliases = { ["vertexai"]: "google" };
+const normalize = (input) => input.toLowerCase().replace(/[\s._-]/g, "");
+const providerByNormalizedId = Object.values(ProviderId).reduce((acc, id) => {
+	acc[normalize(id)] = id;
+	return acc;
+}, {});
+/** Resolves free-form provider text to a canonical id, ignoring case and separators. */
+function resolveProviderId(input) {
+	if (!input) return null;
+	const key = normalize(input);
+	return providerByNormalizedId[key] ?? providerAliases[key] ?? null;
+}
+/** Resolves a runtime provider to its model catalog, using a native alias only when needed. */
+function resolveModelCatalogKey(provider, catalogs) {
+	const key = provider ?? "";
+	return catalogs?.[key] != null ? key : modelCatalogAliases[key] ?? key;
+}
+//#endregion
+//#region src/svg.ts
+/**
+* DOMPurify policy for user-provided SVG icons, shared by the browser uploader and
+* the server trust boundary so a preview and the persisted icon cannot disagree.
+* `use` is re-added for self-contained `<defs>` references (targets restricted by
+* `restrictSvgReferences`); every SMIL element is forbidden so a stored icon
+* cannot animate forever wherever it renders.
+*/
+const SVG_SANITIZE_CONFIG = {
+	USE_PROFILES: {
+		svg: true,
+		svgFilters: true
+	},
+	ADD_TAGS: ["use"],
+	ADD_ATTR: ["fr"],
+	FORBID_TAGS: [
+		"script",
+		"foreignObject",
+		"style",
+		"a",
+		"image",
+		"animate",
+		"animateColor",
+		"animateMotion",
+		"animateTransform",
+		"mpath",
+		"set"
+	],
+	FORBID_ATTR: ["style"]
+};
+const URL_TOKEN_PREFIX = /url\(\s*['"]?\s*/gi;
+/**
+* True when every `url()` token targets a fragment. Backslashes reject the value
+* outright: CSS unescapes idents before tokenizing, so `u\72l(...)` is a `url()`.
+*/
+function referencesOnlyFragments(value) {
+	if (value.includes("\\")) return false;
+	if (!value.toLowerCase().includes("url(")) return true;
+	URL_TOKEN_PREFIX.lastIndex = 0;
+	while (URL_TOKEN_PREFIX.exec(value) !== null) if (value[URL_TOKEN_PREFIX.lastIndex] !== "#") return false;
+	return true;
+}
+/** DOMPurify hook that drops every attribute referencing outside the document. */
+function restrictSvgReferences(node) {
+	const names = [];
+	for (let i = 0; i < node.attributes.length; i += 1) names.push(node.attributes[i].name);
+	for (const name of names) {
+		const value = node.getAttribute(name)?.trim();
+		if (value == null) continue;
+		if (name === "href" || name === "xlink:href") {
+			if (!value.startsWith("#")) node.removeAttribute(name);
+			continue;
+		}
+		if (!referencesOnlyFragments(value)) node.removeAttribute(name);
+	}
+}
+/** SVG names the HTML parser lowercases and its adjustment table does not restore. */
+const UNADJUSTED_SVG_TAGS = [[/(<\/?)fedropshadow\b/gi, "$1feDropShadow"]];
+const SVG_ROOT_TAG = /<svg(\s[^>]*)?>/i;
+/**
+* Makes HTML-mode sanitizer output valid as a standalone `image/svg+xml`
+* document: restores camelCase element names the HTML parser lowercased and
+* declares the SVG namespace on the root, without which an XML parser puts the
+* root in no namespace and the icon renders blank.
+*/
+function finalizeSvgMarkup(markup) {
+	let restored = markup;
+	for (const [pattern, canonical] of UNADJUSTED_SVG_TAGS) restored = restored.replace(pattern, canonical);
+	return restored.replace(SVG_ROOT_TAG, (tag, attributes) => attributes != null && /\sxmlns\s*=/i.test(attributes) ? tag : `<svg xmlns="http://www.w3.org/2000/svg"${attributes ?? ""}>`);
+}
+//#endregion
 //#region src/actions.ts
 function sha1(input) {
 	return crypto.default.createHash("sha1").update(input).digest("hex");
@@ -5384,11 +6488,13 @@ function getUserTimezone() {
 	}
 }
 function createPayload(submission) {
-	const { isEdited, addedConvo, userMessage, isContinued, isTemporary, isRegenerate, conversation, editedContent, ephemeralAgent, endpointOption, manualSkills, clientRequestId, recoverySteerId, expectedPredecessorCreatedAt } = submission;
+	const { isEdited, addedConvo, userMessage, isContinued, isTemporary, isRegenerate, compact, conversation, editedContent, ephemeralAgent, endpointOption, manualSkills, codeApprovalMode, codeEnvironmentMode, codeWorkspaces, clientRequestId, recoverySteerId, expectedPredecessorCreatedAt } = submission;
 	const { conversationId } = require_data_service.tConvoUpdateSchema.parse(conversation);
 	const { endpoint: _e, endpointType } = endpointOption;
 	const endpoint = _e;
-	let server = `${require_data_service.EndpointURLs["agents"]}/${endpoint}`;
+	/** Custom endpoint names are user-defined and may contain `/`, which would
+	* otherwise split into extra path segments and miss the `/:endpoint` route. */
+	let server = `${require_data_service.EndpointURLs["agents"]}/${encodeURIComponent(endpoint)}`;
 	if (require_data_service.isAssistantsEndpoint(endpoint)) server = require_data_service.EndpointURLs[endpointType ?? endpoint] + (isEdited ? "/modify" : "");
 	const payload = {
 		...userMessage,
@@ -5396,12 +6502,18 @@ function createPayload(submission) {
 		endpoint,
 		addedConvo,
 		isTemporary,
-		isRegenerate,
+		/** A compaction borrows the regenerate shape client-side only: the server
+		*  must see it as a compaction, never as a regenerated user turn. */
+		isRegenerate: compact === true ? void 0 : isRegenerate,
+		...compact === true && { compact: true },
 		editedContent,
 		conversationId,
 		isContinued: !!(isEdited && isContinued),
 		ephemeralAgent: require_data_service.isAssistantsEndpoint(endpoint) ? void 0 : ephemeralAgent,
 		manualSkills: require_data_service.isAssistantsEndpoint(endpoint) ? void 0 : manualSkills,
+		codeApprovalMode: require_data_service.isAssistantsEndpoint(endpoint) ? void 0 : codeApprovalMode,
+		codeEnvironmentMode: require_data_service.isAssistantsEndpoint(endpoint) ? void 0 : codeEnvironmentMode,
+		codeWorkspaces: require_data_service.isAssistantsEndpoint(endpoint) ? void 0 : codeWorkspaces,
 		timezone: getUserTimezone(),
 		clientRequestId,
 		recoverySteerId,
@@ -5464,28 +6576,6 @@ const baseDefinitions = {
 		optionType: "conversation",
 		minTags: 0,
 		maxTags: 4
-	},
-	imageDetail: {
-		key: "imageDetail",
-		label: "com_endpoint_plug_image_detail",
-		labelCode: true,
-		description: "com_endpoint_openai_detail",
-		descriptionCode: true,
-		type: "enum",
-		default: "auto",
-		component: "slider",
-		options: [
-			"low",
-			"auto",
-			"high"
-		],
-		enumMappings: {
-			["low"]: "com_ui_low",
-			["auto"]: "com_ui_auto",
-			["high"]: "com_ui_high"
-		},
-		optionType: "conversation",
-		columnSpan: 2
 	}
 };
 const createDefinition = (base, overrides) => {
@@ -5543,6 +6633,30 @@ const librechat = {
 		placeholderCode: true,
 		optionType: "model"
 	},
+	/** Controls how LibreChat encodes image content blocks, not a provider request
+	* parameter — so it belongs to this group and is stripped from model options. */
+	imageDetail: {
+		key: "imageDetail",
+		label: "com_endpoint_plug_image_detail",
+		labelCode: true,
+		description: "com_endpoint_openai_detail",
+		descriptionCode: true,
+		type: "enum",
+		default: "auto",
+		component: "slider",
+		options: [
+			"low",
+			"auto",
+			"high"
+		],
+		enumMappings: {
+			["low"]: "com_ui_low",
+			["auto"]: "com_ui_auto",
+			["high"]: "com_ui_high"
+		},
+		optionType: "conversation",
+		columnSpan: 2
+	},
 	fileTokenLimit: {
 		key: "fileTokenLimit",
 		label: "com_ui_file_token_limit",
@@ -6121,6 +7235,14 @@ const meta = {
 	})
 };
 const google = {
+	/** Bounds the hand-rolled editor enforced through InputNumber, and they stay
+	*  scoped to this endpoint: the shared definition is rendered by every other
+	*  endpoint, whose own context windows may fall outside them. */
+	maxContextTokens: createDefinition(librechat.maxContextTokens, { range: {
+		min: require_data_service.googleSettings.maxContextTokens.min,
+		max: require_data_service.googleSettings.maxContextTokens.max,
+		step: require_data_service.googleSettings.maxContextTokens.step
+	} }),
 	temperature: createDefinition(baseDefinitions.temperature, {
 		default: require_data_service.googleSettings.temperature.default,
 		range: {
@@ -6260,7 +7382,7 @@ const google = {
 const googleConfig = [
 	librechat.modelLabel,
 	librechat.promptPrefix,
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -6279,7 +7401,7 @@ const googleCol1 = [
 	librechat.promptPrefix
 ];
 const googleCol2 = [
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -6303,7 +7425,7 @@ const openAI = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.web_search,
 	openAIParams.reasoning_effort,
 	openAIParams.useResponsesApi,
@@ -6333,7 +7455,7 @@ const openAICol2 = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.reasoning_effort,
 	openAIParams.reasoning_summary,
 	openAIParams.reasoning_mode,
@@ -6574,6 +7696,38 @@ const paramSettings = {
 	[`bedrock-zai`]: bedrockZAI,
 	["google"]: googleConfig
 };
+/**
+* Maps effective backend param names for OpenAI-compatible/Azure endpoints (as deleted from
+* `llmConfig` via `dropParams`, e.g. `maxTokens`) to their corresponding UI/conversation keys
+* (e.g. `max_tokens`). Native providers (anthropic, google, bedrock, ...) already render these
+* same camelCase names as their UI key (e.g. `topP`), so this alias must only be applied to
+* OpenAI-compatible parameter sets — see `resolveDropParamsUIKeys`.
+*/
+const dropParamsBackendToUIKey = {
+	maxTokens: "max_tokens",
+	topP: "top_p",
+	frequencyPenalty: "frequency_penalty",
+	presencePenalty: "presence_penalty"
+};
+/** Endpoint keys whose parameter settings render the OpenAI-compatible (snake_case) UI keys. */
+const openAILikeParamEndpointKeys = new Set([
+	"openAI",
+	"azureOpenAI",
+	"custom",
+	"openrouter"
+]);
+/**
+* Normalizes an admin-configured `dropParams` list into the UI/conversation keys used to hide
+* the matching controls in the settings panels. `endpointKey` should be the same key used to
+* resolve the panel's parameter settings (e.g. `overriddenEndpointKey`); the backend-name alias
+* is only applied for OpenAI-compatible endpoints, since native providers (anthropic, google,
+* bedrock, ...) already use these backend names as their UI key.
+*/
+function resolveDropParamsUIKeys(dropParams, endpointKey) {
+	if (!dropParams || dropParams.length === 0) return /* @__PURE__ */ new Set();
+	if (!openAILikeParamEndpointKeys.has(endpointKey)) return new Set(dropParams);
+	return new Set(dropParams.map((param) => dropParamsBackendToUIKey[param] ?? param));
+}
 const openAIColumns = {
 	col1: openAICol1,
 	col2: openAICol2
@@ -6640,13 +7794,71 @@ const agentParamSettings = Object.entries(presetSettings).reduce((acc, [key, val
 * Resolves model-aware defaults for a settings configuration before rendering.
 * Google's `maxOutputTokens` default depends on the selected Gemini model so that
 * current models (2.5 and 3+) surface their 64K output limit instead of the legacy 8K value.
+* Anthropic prompt-cache controls are only surfaced for models that support them.
 */
 function applyModelAwareDefaults(settings, endpoint, model) {
-	if (endpoint !== "google" || !model) return settings;
-	return settings.map((setting) => setting.key === "maxOutputTokens" ? {
-		...setting,
-		default: require_data_service.googleSettings.maxOutputTokens.reset(model)
-	} : setting);
+	if (!model) return settings;
+	const modelAwareSettings = endpoint === "google" ? settings.map((setting) => {
+		if (setting.key === "maxOutputTokens") return {
+			...setting,
+			default: require_data_service.googleSettings.maxOutputTokens.reset(model)
+		};
+		/** The shared thinking budget range is model-agnostic, so it caps Pro below
+		*  its real ceiling and accepts Flash values the provider rejects. The
+		*  maximum and the positive floor move together. `range.min` stays -1 so
+		*  the "decide automatically" sentinel remains typeable. */
+		if (setting.key === "thinkingBudget" && setting.range != null) {
+			const bounds = require_data_service.getGoogleThinkingBudgetBounds(model);
+			if (bounds != null) return {
+				...setting,
+				range: {
+					...setting.range,
+					max: bounds.max,
+					positiveMin: bounds.min,
+					modelSpecific: true
+				}
+			};
+		}
+		return setting;
+	}) : settings;
+	if (endpoint !== "anthropic" || supportsPromptCache(model)) return modelAwareSettings;
+	return modelAwareSettings.filter((setting) => setting.key !== "promptCache" && setting.key !== "promptCacheTtl");
+}
+//#endregion
+//#region src/agentToolOptions.ts
+const actionDomainSeparatorRegex = /* @__PURE__ */ new RegExp("---", "g");
+/**
+* Collapses the encoded-domain suffix of an action tool name to the shape used
+* by runtime tool definitions. The operation id is deliberately preserved.
+*/
+function normalizeActionToolName(toolName) {
+	if (!require_data_service.isActionTool(toolName)) return toolName;
+	const prefixEnd = toolName.lastIndexOf(require_data_service.actionDelimiter) + require_data_service.actionDelimiter.length;
+	const encodedDomain = toolName.slice(prefixEnd);
+	return toolName.slice(0, prefixEnd) + encodedDomain.replace(actionDomainSeparatorRegex, "_");
+}
+/**
+* Removes Code Interpreter as an allowed caller without mutating the input.
+* Tool entries and unrelated options are preserved; an empty entry is removed.
+*/
+function removeCodeExecutionCaller(toolOptions) {
+	if (toolOptions == null) return toolOptions;
+	const normalized = {};
+	for (const [toolName, options] of Object.entries(toolOptions)) {
+		const callers = options.allowed_callers;
+		if (callers?.includes("code_execution") !== true) {
+			normalized[toolName] = options;
+			continue;
+		}
+		const allowedCallers = callers.filter((caller) => caller !== "code_execution");
+		const { allowed_callers: _removed, ...remainingOptions } = options;
+		const nextOptions = allowedCallers.length > 0 ? {
+			...remainingOptions,
+			allowed_callers: allowedCallers
+		} : remainingOptions;
+		if (Object.keys(nextOptions).length > 0) normalized[toolName] = nextOptions;
+	}
+	return normalized;
 }
 //#endregion
 //#region src/codeEnvRef.ts
@@ -6673,7 +7885,56 @@ const CODE_ENV_KINDS = [
 	"agent",
 	"user"
 ];
+function getCodeEnvRefForProfile(refs, routeKey) {
+	const profileRef = refs?.codeEnvRefs?.[routeKey];
+	if (profileRef) return profileRef;
+	const legacyRef = refs?.codeEnvRef;
+	if (legacyRef && (legacyRef.executionRouteKey ?? legacyRef.executionProfile ?? "default") === routeKey) return legacyRef;
+}
+/** Adds one profile pointer without discarding the other profile's storage object. */
+function mergeCodeEnvRef(refs, ref) {
+	const codeEnvRefs = { ...refs?.codeEnvRefs };
+	const legacyRef = refs?.codeEnvRef;
+	if (legacyRef) codeEnvRefs[legacyRef.executionRouteKey ?? legacyRef.executionProfile ?? "default"] ??= legacyRef;
+	const routeKey = ref.executionRouteKey ?? ref.executionProfile ?? "default";
+	codeEnvRefs[routeKey] = ref;
+	return {
+		codeEnvRef: codeEnvRefs.default ?? codeEnvRefs.stateful ?? ref,
+		codeEnvRefs
+	};
+}
+/** Enumerates every deployment-local pointer, including legacy single-pointer records. */
+function getCodeEnvRefs(refs) {
+	const merged = { ...refs?.codeEnvRefs };
+	const legacyRef = refs?.codeEnvRef;
+	if (legacyRef) merged[legacyRef.executionRouteKey ?? legacyRef.executionProfile ?? "default"] ??= legacyRef;
+	return Object.entries(merged).flatMap(([routeKey, ref]) => ref ? [[routeKey, ref]] : []);
+}
+//#endregion
+//#region src/code/worker.ts
+function isCodeWorkerShell(value) {
+	return value === "posix" || value === "powershell";
+}
+function quotePosix(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function quotePowerShell(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+function createCodeWorkerSetupCommand(pairing, shell, options = {}) {
+	const quote = shell === "powershell" ? quotePowerShell : quotePosix;
+	const pair = `librechat-code pair ${quote(pairing.endpoint)} ${quote(pairing.code)} --worker-id ${quote(pairing.workerId)}`;
+	const run = ["librechat-code run", ...[
+		options.defaultWorkspace === false ? null : "--default-workspace",
+		options.allowWorkspaceWrites === true ? "--allow-workspace-writes" : null,
+		options.allowWorkspaceCommands === true ? "--allow-workspace-commands" : null
+	].filter((value) => value != null)].join(" ");
+	if (shell === "powershell") return `${pair}\n$env:LIBRECHAT_CODE_WORKER_ID = ${quote(pairing.workerId)}\n${run}`;
+	return `${pair}\nLIBRECHAT_CODE_WORKER_ID=${quote(pairing.workerId)} ${run}`;
+}
 //#endregion
+exports.ACTION_METADATA_FILTER_FIELDS = require_data_service.ACTION_METADATA_FILTER_FIELDS;
+exports.AGENT_INSTRUCTION_FILTER_FIELDS = require_data_service.AGENT_INSTRUCTION_FILTER_FIELDS;
 exports.AUTH_USER_DOC_BY_ID_PREFIX = require_data_service.AUTH_USER_DOC_BY_ID_PREFIX;
 exports.AccessRoleIds = require_data_service.AccessRoleIds;
 exports.ActionRequest = ActionRequest;
@@ -6694,30 +7955,51 @@ exports.BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA = BEDROCK_FINE_GRAINED_TOOL_STR
 exports.BEDROCK_OUTPUT_128K_BETA = BEDROCK_OUTPUT_128K_BETA;
 exports.BedrockProviders = require_data_service.BedrockProviders;
 exports.BedrockReasoningConfig = require_data_service.BedrockReasoningConfig;
+exports.CODE_APPROVAL_MODES = require_data_service.CODE_APPROVAL_MODES;
+exports.CODE_ENVIRONMENT_COMMAND_TIMEOUT_DEFAULT_MS = require_data_service.CODE_ENVIRONMENT_COMMAND_TIMEOUT_DEFAULT_MS;
+exports.CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS = require_data_service.CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS;
+exports.CODE_ENVIRONMENT_DECISION_VERSION = require_data_service.CODE_ENVIRONMENT_DECISION_VERSION;
+exports.CODE_ENVIRONMENT_MODES = require_data_service.CODE_ENVIRONMENT_MODES;
 exports.CODE_ENV_KINDS = CODE_ENV_KINDS;
+exports.CODE_WORKSPACE_ID_PATTERN = require_data_service.CODE_WORKSPACE_ID_PATTERN;
+exports.CODE_WORKSPACE_MAX_COUNT = require_data_service.CODE_WORKSPACE_MAX_COUNT;
+exports.CODE_WORKSPACE_OPERATIONS = require_data_service.CODE_WORKSPACE_OPERATIONS;
+exports.CODE_WORKSPACE_SELECTION_ERROR_REASONS = require_data_service.CODE_WORKSPACE_SELECTION_ERROR_REASONS;
+exports.CONVERSATION_STARTER_FILTER_FIELDS = require_data_service.CONVERSATION_STARTER_FILTER_FIELDS;
+exports.CONVERSATION_TITLE_FILTER_FIELDS = require_data_service.CONVERSATION_TITLE_FILTER_FIELDS;
 exports.CacheKeys = require_data_service.CacheKeys;
 exports.Capabilities = require_data_service.Capabilities;
+exports.CodeApprovalModeError = require_data_service.CodeApprovalModeError;
 exports.CohereConstants = require_data_service.CohereConstants;
 exports.ComponentTypes = require_data_service.ComponentTypes;
 exports.Constants = require_data_service.Constants;
 exports.ContentTypes = ContentTypes;
 exports.DATE_RANGE = DATE_RANGE;
 exports.DEFAULT_MEMORY_MAX_INPUT_TOKENS = require_data_service.DEFAULT_MEMORY_MAX_INPUT_TOKENS;
+exports.DefaultLLMDeliveryPath = require_data_service.DefaultLLMDeliveryPath;
 exports.DynamicQueryKeys = require_data_service.DynamicQueryKeys;
 exports.EImageOutputType = require_data_service.EImageOutputType;
 exports.EModelEndpoint = require_data_service.EModelEndpoint;
 exports.EToolResources = require_data_service.EToolResources;
 exports.EndpointURLs = require_data_service.EndpointURLs;
 exports.ErrorTypes = require_data_service.ErrorTypes;
+exports.FEEDBACK_FILTER_FIELDS = require_data_service.FEEDBACK_FILTER_FIELDS;
 exports.FEEDBACK_RATINGS = require_data_service.FEEDBACK_RATINGS;
 exports.FEEDBACK_REASON_KEYS = require_data_service.FEEDBACK_REASON_KEYS;
 exports.FEEDBACK_TAGS = require_data_service.FEEDBACK_TAGS;
+exports.FILE_FILTER_FIELDS = require_data_service.FILE_FILTER_FIELDS;
+exports.FILTER_PII_STARTER_PATTERNS = require_data_service.FILTER_PII_STARTER_PATTERNS;
 exports.FetchTokenConfig = require_data_service.FetchTokenConfig;
 exports.FileContext = require_data_service.FileContext;
 exports.FilePurpose = require_data_service.FilePurpose;
 exports.FileSources = require_data_service.FileSources;
 exports.ForkOptions = require_data_service.ForkOptions;
 exports.FunctionSignature = FunctionSignature;
+exports.HITL_MESSAGE_FILTER_FIELDS = require_data_service.HITL_MESSAGE_FILTER_FIELDS;
+exports.INSIGHTS_AGENT_ID_MAX_LENGTH = INSIGHTS_AGENT_ID_MAX_LENGTH;
+exports.INSIGHTS_MAX_RANGE_DAYS = INSIGHTS_MAX_RANGE_DAYS;
+exports.INSIGHTS_SEARCH_MAX_LENGTH = INSIGHTS_SEARCH_MAX_LENGTH;
+exports.INSIGHTS_SEARCH_MIN_LENGTH = INSIGHTS_SEARCH_MIN_LENGTH;
 exports.INTERFACE_PERMISSION_FIELDS = INTERFACE_PERMISSION_FIELDS;
 exports.ImageDetail = require_data_service.ImageDetail;
 exports.ImageDetailCost = require_data_service.ImageDetailCost;
@@ -6725,15 +8007,36 @@ exports.ImageVisionTool = require_data_service.ImageVisionTool;
 exports.InfiniteCollections = require_data_service.InfiniteCollections;
 exports.InvocationMode = InvocationMode;
 exports.KnownEndpoints = require_data_service.KnownEndpoints;
+exports.LANGFUSE_TRACE_CONVERSATION_METADATA_FIELDS = require_data_service.LANGFUSE_TRACE_CONVERSATION_METADATA_FIELDS;
+exports.LANGFUSE_TRACE_USER_ID_FIELDS = require_data_service.LANGFUSE_TRACE_USER_ID_FIELDS;
+exports.LANGFUSE_TRACE_USER_METADATA_FIELDS = require_data_service.LANGFUSE_TRACE_USER_METADATA_FIELDS;
 exports.LocalStorageKeys = require_data_service.LocalStorageKeys;
+exports.MAX_CHAT_PROJECT_DESCRIPTION_LENGTH = require_data_service.MAX_CHAT_PROJECT_DESCRIPTION_LENGTH;
+exports.MAX_CHAT_PROJECT_NAME_LENGTH = require_data_service.MAX_CHAT_PROJECT_NAME_LENGTH;
+exports.MAX_GRAPH_SUBAGENT_MEMBERS = require_data_service.MAX_GRAPH_SUBAGENT_MEMBERS;
+exports.MAX_MCP_ICON_PATH_LENGTH = require_data_service.MAX_MCP_ICON_PATH_LENGTH;
+exports.MAX_PII_CUSTOM_PATTERNS_TOTAL = require_data_service.MAX_PII_CUSTOM_PATTERNS_TOTAL;
+exports.MAX_PII_CUSTOM_REGEX_CHARACTERS = require_data_service.MAX_PII_CUSTOM_REGEX_CHARACTERS;
+exports.MAX_PII_CUSTOM_REGEX_INSTRUCTIONS = require_data_service.MAX_PII_CUSTOM_REGEX_INSTRUCTIONS;
+exports.MAX_PII_PATTERNS_PER_SOURCE = require_data_service.MAX_PII_PATTERNS_PER_SOURCE;
+exports.MAX_PII_PATTERN_ID_LENGTH = require_data_service.MAX_PII_PATTERN_ID_LENGTH;
+exports.MAX_PII_PATTERN_LABEL_LENGTH = require_data_service.MAX_PII_PATTERN_LABEL_LENGTH;
+exports.MAX_PII_PATTERN_LENGTH = require_data_service.MAX_PII_PATTERN_LENGTH;
 exports.MAX_SUBAGENTS = require_data_service.MAX_SUBAGENTS;
+exports.MAX_SUBAGENTS_CEILING = require_data_service.MAX_SUBAGENTS_CEILING;
 exports.MAX_SUBAGENT_DEPTH = require_data_service.MAX_SUBAGENT_DEPTH;
 exports.MAX_SUBAGENT_GRAPH_NODES = require_data_service.MAX_SUBAGENT_GRAPH_NODES;
 exports.MAX_SUBAGENT_RUN_CONFIGS = require_data_service.MAX_SUBAGENT_RUN_CONFIGS;
 exports.MCPOptionsSchema = require_data_service.MCPOptionsSchema;
 exports.MCPServerUserInputSchema = require_data_service.MCPServerUserInputSchema;
 exports.MCPServersSchema = require_data_service.MCPServersSchema;
+exports.MCP_SERVER_TITLE_ERROR = require_data_service.MCP_SERVER_TITLE_ERROR;
+exports.MCP_SERVER_TITLE_PATTERN = require_data_service.MCP_SERVER_TITLE_PATTERN;
 exports.MCP_USER_INPUT_FIELDS = require_data_service.MCP_USER_INPUT_FIELDS;
+exports.MEMORY_FILTER_FIELDS = require_data_service.MEMORY_FILTER_FIELDS;
+exports.MESSAGE_FILTER_FIELDS = require_data_service.MESSAGE_FILTER_FIELDS;
+exports.MIN_REPORTABLE_RUN_STEP_DURATION_MS = MIN_REPORTABLE_RUN_STEP_DURATION_MS;
+exports.MODEL_PARAMETER_FILTER_FIELDS = require_data_service.MODEL_PARAMETER_FILTER_FIELDS;
 exports.MYTHOS_CLASS_FAMILIES = require_data_service.MYTHOS_CLASS_FAMILIES;
 exports.MemoryScope = require_data_service.MemoryScope;
 exports.MessageContentTypes = require_data_service.MessageContentTypes;
@@ -6742,17 +8045,21 @@ exports.OCRStrategy = require_data_service.OCRStrategy;
 exports.OptionTypes = require_data_service.OptionTypes;
 exports.PERMISSION_SUB_KEYS = PERMISSION_SUB_KEYS;
 exports.PERMISSION_TYPE_INTERFACE_FIELDS = PERMISSION_TYPE_INTERFACE_FIELDS;
+exports.PROMPT_FILTER_FIELDS = require_data_service.PROMPT_FILTER_FIELDS;
 exports.PermissionBits = require_data_service.PermissionBits;
 exports.PermissionTypes = PermissionTypes;
 exports.Permissions = Permissions;
 exports.PrincipalModel = require_data_service.PrincipalModel;
 exports.PrincipalType = require_data_service.PrincipalType;
+exports.ProviderId = ProviderId;
 exports.Providers = require_data_service.Providers;
 exports.QueryKeys = require_data_service.QueryKeys;
 exports.REFILL_INTERVAL_UNITS = require_data_service.REFILL_INTERVAL_UNITS;
+exports.RUNTIME_CONFIG_INTERFACE_FIELDS = RUNTIME_CONFIG_INTERFACE_FIELDS;
 exports.RateLimitPrefix = require_data_service.RateLimitPrefix;
 exports.ReasoningContext = require_data_service.ReasoningContext;
 exports.ReasoningEffort = require_data_service.ReasoningEffort;
+exports.ReasoningLabelEvents = ReasoningLabelEvents;
 exports.ReasoningMode = require_data_service.ReasoningMode;
 exports.ReasoningParameterFormat = require_data_service.ReasoningParameterFormat;
 exports.ReasoningResponseKey = require_data_service.ReasoningResponseKey;
@@ -6761,11 +8068,13 @@ exports.RerankerTypes = require_data_service.RerankerTypes;
 exports.ResourceType = require_data_service.ResourceType;
 exports.RetentionMode = require_data_service.RetentionMode;
 exports.RunStatus = require_data_service.RunStatus;
+exports.SCHEDULE_CRON_MAX_LENGTH = SCHEDULE_CRON_MAX_LENGTH;
 exports.SEPARATORS = SEPARATORS;
 exports.SKILL_BODY_MAX_LENGTH = SKILL_BODY_MAX_LENGTH;
 exports.SKILL_DESCRIPTION_MAX_LENGTH = SKILL_DESCRIPTION_MAX_LENGTH;
 exports.SKILL_DESCRIPTION_SHORT_THRESHOLD = SKILL_DESCRIPTION_SHORT_THRESHOLD;
 exports.SKILL_DISPLAY_TITLE_MAX_LENGTH = SKILL_DISPLAY_TITLE_MAX_LENGTH;
+exports.SKILL_FILTER_FIELDS = require_data_service.SKILL_FILTER_FIELDS;
 exports.SKILL_NAME_MAX_LENGTH = SKILL_NAME_MAX_LENGTH;
 exports.SKILL_NAME_PATTERN = SKILL_NAME_PATTERN;
 exports.SKILL_SYNC_DEFAULT_DISCOVERY_DEPTH = require_data_service.SKILL_SYNC_DEFAULT_DISCOVERY_DEPTH;
@@ -6773,7 +8082,11 @@ exports.SKILL_SYNC_MAX_DISCOVERY_DEPTH = require_data_service.SKILL_SYNC_MAX_DIS
 exports.SKILL_SYNC_MAX_INTERVAL_MINUTES = require_data_service.SKILL_SYNC_MAX_INTERVAL_MINUTES;
 exports.SKILL_SYNC_MIN_INTERVAL_MINUTES = require_data_service.SKILL_SYNC_MIN_INTERVAL_MINUTES;
 exports.SSEOptionsSchema = require_data_service.SSEOptionsSchema;
+exports.STATEFUL_CODE_ENVIRONMENTS = require_data_service.STATEFUL_CODE_ENVIRONMENTS;
+exports.STORED_MESSAGE_FILTER_FIELDS = require_data_service.STORED_MESSAGE_FILTER_FIELDS;
 exports.STTProviders = require_data_service.STTProviders;
+exports.SVG_SANITIZE_CONFIG = SVG_SANITIZE_CONFIG;
+exports.SYSTEM_LLM_DELIVERY_DEFAULTS = SYSTEM_LLM_DELIVERY_DEFAULTS;
 exports.SafeSearchTypes = require_data_service.SafeSearchTypes;
 exports.ScraperProviders = require_data_service.ScraperProviders;
 exports.SearchCategories = require_data_service.SearchCategories;
@@ -6781,6 +8094,7 @@ exports.SearchProviders = require_data_service.SearchProviders;
 exports.SettingTypes = require_data_service.SettingTypes;
 exports.SettingsTabValues = require_data_service.SettingsTabValues;
 exports.SettingsViews = require_data_service.SettingsViews;
+exports.SkillsScope = require_data_service.SkillsScope;
 exports.StdioOptionsSchema = require_data_service.StdioOptionsSchema;
 exports.SteerEvents = SteerEvents;
 exports.StepEvents = StepEvents;
@@ -6789,6 +8103,10 @@ exports.StepTypes = StepTypes;
 exports.StreamableHTTPOptionsSchema = require_data_service.StreamableHTTPOptionsSchema;
 exports.SystemCategories = require_data_service.SystemCategories;
 exports.SystemRoles = SystemRoles;
+exports.TOOL_ARGUMENT_FILTER_FIELDS = require_data_service.TOOL_ARGUMENT_FILTER_FIELDS;
+exports.TRACE_CURSOR_MAX_LENGTH = TRACE_CURSOR_MAX_LENGTH;
+exports.TRACE_RECORD_ID_MAX_LENGTH = TRACE_RECORD_ID_MAX_LENGTH;
+exports.TRACE_SOURCE_ID_MAX_LENGTH = TRACE_SOURCE_ID_MAX_LENGTH;
 exports.TTSProviders = require_data_service.TTSProviders;
 exports.ThinkingDisplay = require_data_service.ThinkingDisplay;
 exports.ThinkingLevel = require_data_service.ThinkingLevel;
@@ -6806,8 +8124,16 @@ exports.accessRoleToPermBits = require_data_service.accessRoleToPermBits;
 exports.accordian = accordian;
 exports.actionDelimiter = require_data_service.actionDelimiter;
 exports.actionDomainSeparator = require_data_service.actionDomainSeparator;
+exports.actionMetadataFilterFieldSchema = require_data_service.actionMetadataFilterFieldSchema;
+exports.agentGitIdentitySchema = require_data_service.agentGitIdentitySchema;
+exports.agentInstructionFilterFieldSchema = require_data_service.agentInstructionFilterFieldSchema;
 exports.agentParamSettings = agentParamSettings;
 exports.agentPermissionsSchema = agentPermissionsSchema;
+exports.agentQueuedTurnCapabilitySchema = agentQueuedTurnCapabilitySchema;
+exports.agentQueuedTurnDurability = agentQueuedTurnDurability;
+exports.agentQueuedTurnFileRefSchema = agentQueuedTurnFileRefSchema;
+exports.agentQueuedTurnReceiptSchema = agentQueuedTurnReceiptSchema;
+exports.agentQueuedTurnStatuses = agentQueuedTurnStatuses;
 exports.agentsBaseSchema = require_data_service.agentsBaseSchema;
 exports.agentsEndpointSchema = require_data_service.agentsEndpointSchema;
 exports.agentsSchema = require_data_service.agentsSchema;
@@ -6852,7 +8178,12 @@ exports.buildServerNameAliases = require_data_service.buildServerNameAliases;
 exports.buildTree = buildTree;
 exports.button = button;
 exports.cacheSubsetProviders = require_data_service.cacheSubsetProviders;
+exports.cadenceIntervalMinutes = cadenceIntervalMinutes;
+exports.cadenceToCron = cadenceToCron;
 exports.calendar = calendar;
+exports.canToolResourceConsume = canToolResourceConsume;
+exports.cancelAgentQueuedTurnResponseSchema = cancelAgentQueuedTurnResponseSchema;
+exports.cancelAgentQueuedTurnSchema = cancelAgentQueuedTurnSchema;
 exports.capsEffortWhenThinkingDisabled = capsEffortWhenThinkingDisabled;
 exports.card = card;
 exports.carousel = carousel;
@@ -6862,7 +8193,11 @@ exports.checkpointerSchema = require_data_service.checkpointerSchema;
 exports.checkpointerTypeSchema = require_data_service.checkpointerTypeSchema;
 exports.clampEffortForDisabledThinking = clampEffortForDisabledThinking;
 exports.clampOutputConfigEffort = clampOutputConfigEffort;
+exports.clampSettingRange = require_data_service.clampSettingRange;
 exports.cloudfrontConfigSchema = require_data_service.cloudfrontConfigSchema;
+exports.codeEnvironmentPermissionDecisionSchema = require_data_service.codeEnvironmentPermissionDecisionSchema;
+exports.codeEnvironmentUserConfigSchema = require_data_service.codeEnvironmentUserConfigSchema;
+exports.codeEnvironmentUserSettingsSchema = require_data_service.codeEnvironmentUserSettingsSchema;
 exports.codeInterpreterMimeTypes = require_data_service.codeInterpreterMimeTypes;
 exports.codeInterpreterMimeTypesList = require_data_service.codeInterpreterMimeTypesList;
 exports.codeTypeMapping = require_data_service.codeTypeMapping;
@@ -6874,9 +8209,14 @@ exports.compactAssistantSchema = require_data_service.compactAssistantSchema;
 exports.compactGoogleSchema = require_data_service.compactGoogleSchema;
 exports.configSchema = require_data_service.configSchema;
 exports.contextPruningSchema = require_data_service.contextPruningSchema;
+exports.conversationStarterFilterFieldSchema = require_data_service.conversationStarterFilterFieldSchema;
+exports.conversationTitleFilterFieldSchema = require_data_service.conversationTitleFilterFieldSchema;
 exports.convertStringsToRegex = require_data_service.convertStringsToRegex;
+exports.createCodeWorkerSetupCommand = createCodeWorkerSetupCommand;
 exports.createPayload = createPayload;
+exports.createSchedulePayloadSchema = createSchedulePayloadSchema;
 exports.createURL = createURL;
+exports.cronCadenceSchema = cronCadenceSchema;
 Object.defineProperty(exports, "dataService", {
 	enumerable: true,
 	get: function() {
@@ -6888,6 +8228,7 @@ exports.defaultAgentFormValues = require_data_service.defaultAgentFormValues;
 exports.defaultAssistantFormValues = require_data_service.defaultAssistantFormValues;
 exports.defaultAssistantsVersion = require_data_service.defaultAssistantsVersion;
 exports.defaultEndpoints = require_data_service.defaultEndpoints;
+exports.defaultLLMDeliveryPathSchema = require_data_service.defaultLLMDeliveryPathSchema;
 exports.defaultModels = require_data_service.defaultModels;
 exports.defaultOCRMimeTypes = require_data_service.defaultOCRMimeTypes;
 exports.defaultOrderQuery = require_data_service.defaultOrderQuery;
@@ -6917,6 +8258,9 @@ exports.encodeEphemeralAgentId = encodeEphemeralAgentId;
 exports.endpointFileConfigSchema = require_data_service.endpointFileConfigSchema;
 exports.endpointSchema = require_data_service.endpointSchema;
 exports.endpointSettings = require_data_service.endpointSettings;
+exports.endpointToProvider = endpointToProvider;
+exports.enqueueAgentQueuedTurnResponseSchema = enqueueAgentQueuedTurnResponseSchema;
+exports.enqueueAgentQueuedTurnSchema = enqueueAgentQueuedTurnSchema;
 exports.envVarRegex = require_data_service.envVarRegex;
 exports.errorsToString = errorsToString;
 exports.essentialShadcnComponents = essentialShadcnComponents;
@@ -6927,33 +8271,53 @@ exports.extendedModelEndpointSchema = require_data_service.extendedModelEndpoint
 exports.extractDomainFromUrl = extractDomainFromUrl;
 exports.extractEnvVariable = require_data_service.extractEnvVariable;
 exports.extractVariableName = require_data_service.extractVariableName;
+exports.feedbackFilterFieldSchema = require_data_service.feedbackFilterFieldSchema;
 exports.feedbackRatingSchema = require_data_service.feedbackRatingSchema;
 exports.feedbackSchema = require_data_service.feedbackSchema;
 exports.feedbackTagKeySchema = require_data_service.feedbackTagKeySchema;
 exports.fileCitationsPermissionsSchema = fileCitationsPermissionsSchema;
 exports.fileConfig = require_data_service.fileConfig;
 exports.fileConfigSchema = require_data_service.fileConfigSchema;
+exports.fileFilterFieldSchema = require_data_service.fileFilterFieldSchema;
 exports.fileSearchPermissionsSchema = fileSearchPermissionsSchema;
 exports.fileSourceSchema = require_data_service.fileSourceSchema;
 exports.fileStorageSchema = require_data_service.fileStorageSchema;
 exports.fileStrategiesSchema = require_data_service.fileStrategiesSchema;
+exports.filterPiiActionSchema = require_data_service.filterPiiActionSchema;
+exports.filterPiiCustomPatternSchema = require_data_service.filterPiiCustomPatternSchema;
+exports.filterPiiRegexSchema = require_data_service.filterPiiRegexSchema;
+exports.filterPiiStarterPatternSchema = require_data_service.filterPiiStarterPatternSchema;
+exports.filtersConfigSchema = require_data_service.filtersConfigSchema;
+exports.finalizeSvgMarkup = finalizeSvgMarkup;
 exports.findLastSeparatorIndex = findLastSeparatorIndex;
+exports.findMessageById = findMessageById;
 exports.fullMimeTypesList = require_data_service.fullMimeTypesList;
 exports.generateDynamicSchema = require_data_service.generateDynamicSchema;
 exports.generateGoogleSchema = require_data_service.generateGoogleSchema;
 exports.generateOpenAISchema = require_data_service.generateOpenAISchema;
+exports.getAllowedCodeApprovalModes = require_data_service.getAllowedCodeApprovalModes;
+exports.getCodeEnvRefForProfile = getCodeEnvRefForProfile;
+exports.getCodeEnvRefs = getCodeEnvRefs;
 exports.getConfigDefaults = require_data_service.getConfigDefaults;
 exports.getConfiguredMimeAccept = require_data_service.getConfiguredMimeAccept;
 exports.getDefaultParamsEndpoint = require_data_service.getDefaultParamsEndpoint;
+exports.getDocumentFileExtension = require_data_service.getDocumentFileExtension;
 exports.getEnabledEndpoints = getEnabledEndpoints;
 exports.getEndpointField = require_data_service.getEndpointField;
 exports.getEndpointFileConfig = require_data_service.getEndpointFileConfig;
+exports.getEphemeralSender = getEphemeralSender;
 exports.getFirstDefinedValue = getFirstDefinedValue;
+exports.getGoogleThinkingBudgetBounds = require_data_service.getGoogleThinkingBudgetBounds;
+exports.getGoogleThinkingBudgetMax = require_data_service.getGoogleThinkingBudgetMax;
+exports.getMaxSubagents = require_data_service.getMaxSubagents;
 exports.getModelKey = require_data_service.getModelKey;
 exports.getNonEmptyValue = getNonEmptyValue;
+exports.getPiiRegexProgramSize = require_data_service.getPiiRegexProgramSize;
 exports.getRefillEligibilityDate = require_data_service.getRefillEligibilityDate;
 exports.getResourcePermissionsResponseSchema = require_data_service.getResourcePermissionsResponseSchema;
 exports.getResponseSender = getResponseSender;
+exports.getRunStepDurationMs = getRunStepDurationMs;
+exports.getScheduleMCPDisabledReason = getScheduleMCPDisabledReason;
 exports.getSchemaDefaults = require_data_service.getSchemaDefaults;
 exports.getSettingsKeys = require_data_service.getSettingsKeys;
 exports.getTagByKey = require_data_service.getTagByKey;
@@ -6963,7 +8327,13 @@ exports.googleBaseSchema = require_data_service.googleBaseSchema;
 exports.googleGenConfigSchema = require_data_service.googleGenConfigSchema;
 exports.googleSchema = require_data_service.googleSchema;
 exports.googleSettings = require_data_service.googleSettings;
+exports.hasActiveFiltersConfig = require_data_service.hasActiveFiltersConfig;
+exports.hasActivePiiFields = require_data_service.hasActivePiiFields;
+exports.hasActivePiiPatterns = require_data_service.hasActivePiiPatterns;
 exports.hasPermissions = require_data_service.hasPermissions;
+exports.hasProcessMCPServerConfig = require_data_service.hasProcessMCPServerConfig;
+exports.hasTextExtractionPath = hasTextExtractionPath;
+exports.hasToolCallErrorPrefix = hasToolCallErrorPrefix;
 exports.hostImageIdSuffix = require_data_service.hostImageIdSuffix;
 exports.hostImageNamePrefix = require_data_service.hostImageNamePrefix;
 exports.hoverCard = hoverCard;
@@ -6984,42 +8354,76 @@ exports.isAnthropicDocumentType = require_data_service.isAnthropicDocumentType;
 exports.isAnthropicTextDocumentType = require_data_service.isAnthropicTextDocumentType;
 exports.isAssistantsEndpoint = require_data_service.isAssistantsEndpoint;
 exports.isBedrockDocumentType = require_data_service.isBedrockDocumentType;
+exports.isCodeEnvironmentMode = require_data_service.isCodeEnvironmentMode;
+exports.isCodeWorkerShell = isCodeWorkerShell;
+exports.isCodeWorkspaceSelection = require_data_service.isCodeWorkspaceSelection;
+exports.isCodeWorkspaceSelectionErrorReason = require_data_service.isCodeWorkspaceSelectionErrorReason;
+exports.isCodeWorkspaceSelections = require_data_service.isCodeWorkspaceSelections;
+exports.isCompactedLeaf = isCompactedLeaf;
+exports.isCronCadence = isCronCadence;
 exports.isDocumentSupportedProvider = require_data_service.isDocumentSupportedProvider;
 exports.isEphemeralAgentId = isEphemeralAgentId;
 exports.isImageVisionTool = require_data_service.isImageVisionTool;
+exports.isKnownProviderIdentifier = require_data_service.isKnownProviderIdentifier;
+exports.isMediaSupportedProvider = require_data_service.isMediaSupportedProvider;
+exports.isMessageFileUpload = require_data_service.isMessageFileUpload;
 exports.isMythosClassModel = require_data_service.isMythosClassModel;
+exports.isNativelyReadableText = isNativelyReadableText;
 exports.isOpenAILikeProvider = require_data_service.isOpenAILikeProvider;
 exports.isParamEndpoint = require_data_service.isParamEndpoint;
 exports.isPermissiveMimeConfig = require_data_service.isPermissiveMimeConfig;
+exports.isProcessMCPServerConfig = require_data_service.isProcessMCPServerConfig;
+exports.isProcessMCPServerField = require_data_service.isProcessMCPServerField;
 exports.isRemoteOidcUrlAllowed = require_data_service.isRemoteOidcUrlAllowed;
+exports.isReportableRunStepDuration = isReportableRunStepDuration;
+exports.isResponsesApiUpload = require_data_service.isResponsesApiUpload;
+exports.isSecureCodeEnvironmentControlURL = require_data_service.isSecureCodeEnvironmentControlURL;
 exports.isSensitiveEnvVar = require_data_service.isSensitiveEnvVar;
+exports.isSpeechProviderConfigured = require_data_service.isSpeechProviderConfigured;
 exports.isSystemRoleName = isSystemRoleName;
 exports.isThinkingDisabled = isThinkingDisabled;
 exports.isUUID = require_data_service.isUUID;
+exports.isUserInitiatedCompaction = isUserInitiatedCompaction;
+exports.isValidCronExpression = isValidCronExpression;
+exports.knownEndpointToProvider = knownEndpointToProvider;
 exports.label = label;
 exports.langfuseConfigSchema = require_data_service.langfuseConfigSchema;
+exports.langfuseTraceConfigSchema = require_data_service.langfuseTraceConfigSchema;
 exports.librechat = librechat;
+exports.listAgentQueuedTurnsResponseSchema = listAgentQueuedTurnsResponseSchema;
+exports.listAgentQueuedTurnsSchema = listAgentQueuedTurnsSchema;
+exports.listConfiguredSpeechProviders = require_data_service.listConfiguredSpeechProviders;
 exports.loginPage = require_data_service.loginPage;
 exports.mapGroupToAzureConfig = mapGroupToAzureConfig;
 exports.mapModelToAzureConfig = mapModelToAzureConfig;
 exports.marketplacePermissionsSchema = marketplacePermissionsSchema;
+exports.materializeModelSpecEndpoints = require_data_service.materializeModelSpecEndpoints;
 exports.mbToBytes = require_data_service.mbToBytes;
+exports.mcpRefreshDefaults = require_data_service.mcpRefreshDefaults;
 exports.mcpServersPermissionsSchema = mcpServersPermissionsSchema;
+exports.mediaSupportedProviders = require_data_service.mediaSupportedProviders;
 exports.megabyte = require_data_service.megabyte;
+exports.memoryFilterFieldSchema = require_data_service.memoryFilterFieldSchema;
 exports.memoryPermissionsSchema = memoryPermissionsSchema;
 exports.memorySchema = require_data_service.memorySchema;
 exports.menuBar = menuBar;
+exports.mergeCodeEnvRef = mergeCodeEnvRef;
 exports.mergeFileConfig = require_data_service.mergeFileConfig;
+exports.messageFilterFieldSchema = require_data_service.messageFilterFieldSchema;
 exports.messageFilterPiiSchema = require_data_service.messageFilterPiiSchema;
 exports.messageFilterSchema = require_data_service.messageFilterSchema;
 exports.mimeTypeAliases = require_data_service.mimeTypeAliases;
 exports.modelConfigSchema = require_data_service.modelConfigSchema;
+exports.modelParameterFilterFieldSchema = require_data_service.modelParameterFilterFieldSchema;
 exports.modelSpecSubagentsSchema = require_data_service.modelSpecSubagentsSchema;
 exports.modularEndpoints = require_data_service.modularEndpoints;
 exports.multiConvoPermissionsSchema = multiConvoPermissionsSchema;
 exports.navigationMenu = navigationMenu;
+exports.nextRunInstants = nextRunInstants;
+exports.normalizeActionToolName = normalizeActionToolName;
 exports.normalizeEndpointName = require_data_service.normalizeEndpointName;
 exports.normalizeMCPToolKey = require_data_service.normalizeMCPToolKey;
+exports.normalizeSearxngEngines = require_data_service.normalizeSearxngEngines;
 exports.normalizeServerName = require_data_service.normalizeServerName;
 exports.ocrSchema = require_data_service.ocrSchema;
 exports.omitsSamplingParameters = omitsSamplingParameters;
@@ -7030,6 +8434,7 @@ exports.openAISettings = require_data_service.openAISettings;
 exports.openRouterSchema = require_data_service.openRouterSchema;
 exports.openapiToFunction = openapiToFunction;
 exports.orderEndpointsConfig = orderEndpointsConfig;
+exports.outputTokensFromUsage = outputTokensFromUsage;
 exports.pagination = pagination;
 exports.paramDefinitionSchema = require_data_service.paramDefinitionSchema;
 exports.paramEndpoints = require_data_service.paramEndpoints;
@@ -7037,6 +8442,7 @@ exports.paramSettings = paramSettings;
 exports.parseCompactConvo = parseCompactConvo;
 exports.parseConvo = parseConvo;
 exports.parseEphemeralAgentId = parseEphemeralAgentId;
+exports.parseLangChainErrorCode = parseLangChainErrorCode;
 exports.parseTextParts = parseTextParts;
 exports.peoplePickerPermissionsSchema = peoplePickerPermissionsSchema;
 exports.permBitsToAccessLevel = require_data_service.permBitsToAccessLevel;
@@ -7046,32 +8452,60 @@ exports.popover = popover;
 exports.presetSettings = presetSettings;
 exports.principalSchema = require_data_service.principalSchema;
 exports.progress = progress;
+exports.promptFilterFieldSchema = require_data_service.promptFilterFieldSchema;
 exports.promptPermissionsSchema = promptPermissionsSchema;
 exports.promptTokensFromUsage = promptTokensFromUsage;
 exports.providerEndpointMap = require_data_service.providerEndpointMap;
 exports.radioGroup = radioGroup;
 exports.rateLimitSchema = require_data_service.rateLimitSchema;
+exports.readScheduleMCPOutcomes = readScheduleMCPOutcomes;
 exports.reconcileContextUsage = reconcileContextUsage;
+exports.reconcileContextUsageFromEvent = reconcileContextUsageFromEvent;
 exports.registerPage = require_data_service.registerPage;
 exports.remoteAgentsPermissionsSchema = remoteAgentsPermissionsSchema;
+exports.removeCodeExecutionCaller = removeCodeExecutionCaller;
 exports.removeNullishValues = require_data_service.removeNullishValues;
 exports.replaceSpecialVars = replaceSpecialVars;
 exports.request = require_data_service.request_default;
 exports.requiresExplicitThinkingDisabled = requiresExplicitThinkingDisabled;
+exports.resolveAgentSkillsScope = require_data_service.resolveAgentSkillsScope;
+exports.resolveAllowedStatefulCodeEnvironments = require_data_service.resolveAllowedStatefulCodeEnvironments;
+exports.resolveCodeApprovalMode = require_data_service.resolveCodeApprovalMode;
+exports.resolveCodePermissionDecision = require_data_service.resolveCodePermissionDecision;
+exports.resolveDefaultLLMDeliveryPath = resolveDefaultLLMDeliveryPath;
+exports.resolveDefaultUploadLLMDeliveryPath = resolveDefaultUploadLLMDeliveryPath;
+exports.resolveDropParamsUIKeys = resolveDropParamsUIKeys;
 exports.resolveEndpointType = require_data_service.resolveEndpointType;
+exports.resolveModelCatalogKey = resolveModelCatalogKey;
+exports.resolveModelSpecEndpoint = require_data_service.resolveModelSpecEndpoint;
+exports.resolveProviderId = resolveProviderId;
 exports.resolveRef = resolveRef;
+exports.resolveSandboxFilename = require_data_service.resolveSandboxFilename;
+exports.resolveStatefulCodeEnvironment = require_data_service.resolveStatefulCodeEnvironment;
 exports.resolveThinkingDisplay = resolveThinkingDisplay;
+exports.resolveTraceViewerConfig = require_data_service.resolveTraceViewerConfig;
+exports.resolveUploadDestination = resolveUploadDestination;
+exports.resolveUploadLLMDeliveryPath = resolveUploadLLMDeliveryPath;
+exports.resolveUseResponsesApi = require_data_service.resolveUseResponsesApi;
 exports.resourcePermissionsResponseSchema = require_data_service.resourcePermissionsResponseSchema;
+exports.restrictSvgReferences = restrictSvgReferences;
 exports.retainRecentConfigSchema = require_data_service.retainRecentConfigSchema;
 exports.retrievalMimeTypes = require_data_service.retrievalMimeTypes;
 exports.retrievalMimeTypesList = require_data_service.retrievalMimeTypesList;
 exports.roleDefaults = roleDefaults;
 exports.roleSchema = roleSchema;
 exports.runCodePermissionsSchema = runCodePermissionsSchema;
+exports.scheduleCadenceSchema = scheduleCadenceSchema;
+exports.scheduleFrequencies = scheduleFrequencies;
+exports.scheduleMCPOutcomeSchema = scheduleMCPOutcomeSchema;
+exports.scheduleStructuredFrequencies = scheduleStructuredFrequencies;
+exports.scheduleTargets = scheduleTargets;
+exports.schedulesPermissionsSchema = schedulesPermissionsSchema;
 exports.select = select;
 exports.separator = separator;
 exports.setAcceptLanguageHeader = require_data_service.setAcceptLanguageHeader;
 exports.setFileConfigRegexCompiler = require_data_service.setFileConfigRegexCompiler;
+exports.setMaxSubagents = require_data_service.setMaxSubagents;
 exports.setMessageFilterRegexValidator = require_data_service.setMessageFilterRegexValidator;
 exports.setTokenHeader = require_data_service.setTokenHeader;
 exports.sha1 = sha1;
@@ -7079,6 +8513,7 @@ exports.shadcnComponents = shadcnComponents;
 exports.sharedFileDownload = require_data_service.sharedFileDownload;
 exports.sharedLinksPermissionsSchema = sharedLinksPermissionsSchema;
 exports.skeleton = skeleton;
+exports.skillFilterFieldSchema = require_data_service.skillFilterFieldSchema;
 exports.skillPermissionsSchema = skillPermissionsSchema;
 exports.skillSyncConfigSchema = require_data_service.skillSyncConfigSchema;
 exports.skillSyncGitHubSourceSchema = require_data_service.skillSyncGitHubSourceSchema;
@@ -7088,6 +8523,13 @@ exports.specsConfigSchema = require_data_service.specsConfigSchema;
 exports.splitMCPToolKey = require_data_service.splitMCPToolKey;
 exports.splitToolCallName = require_data_service.splitToolCallName;
 exports.stripAgentIdSuffix = stripAgentIdSuffix;
+exports.stripLangChainTroubleshootingUrl = stripLangChainTroubleshootingUrl;
+exports.stripReasoningLabelMetadata = stripReasoningLabelMetadata;
+exports.stripServerNamePrefix = require_data_service.stripServerNamePrefix;
+exports.stripServerNamePrefixes = require_data_service.stripServerNamePrefixes;
+exports.stripToolCallErrorPrefix = stripToolCallErrorPrefix;
+exports.structuredCadenceSchema = structuredCadenceSchema;
+exports.subagentThreadLineageSchema = require_data_service.subagentThreadLineageSchema;
 exports.summarizationConfigSchema = require_data_service.summarizationConfigSchema;
 exports.summarizationTriggerSchema = require_data_service.summarizationTriggerSchema;
 exports.supportedMimeTypes = require_data_service.supportedMimeTypes;
@@ -7095,6 +8537,7 @@ exports.supportsAdaptiveThinking = supportsAdaptiveThinking;
 exports.supportsBalanceCheck = require_data_service.supportsBalanceCheck;
 exports.supportsContext1m = supportsContext1m;
 exports.supportsFiles = require_data_service.supportsFiles;
+exports.supportsPromptCache = supportsPromptCache;
 exports.switchComponent = switchComponent;
 exports.tBannerSchema = require_data_service.tBannerSchema;
 exports.tConversationSchema = require_data_service.tConversationSchema;
@@ -7122,13 +8565,19 @@ exports.toggleGroup = toggleGroup;
 exports.toolApprovalHookConfigSchema = require_data_service.toolApprovalHookConfigSchema;
 exports.toolApprovalModeSchema = require_data_service.toolApprovalModeSchema;
 exports.toolApprovalPolicySchema = require_data_service.toolApprovalPolicySchema;
+exports.toolArgumentFilterFieldSchema = require_data_service.toolArgumentFilterFieldSchema;
 exports.tooltip = tooltip;
+exports.traceViewerDefaults = require_data_service.traceViewerDefaults;
+exports.traceViewerLimits = require_data_service.traceViewerLimits;
 exports.transactionsSchema = require_data_service.transactionsSchema;
 exports.turnstileOptionsSchema = require_data_service.turnstileOptionsSchema;
 exports.turnstileSchema = require_data_service.turnstileSchema;
+exports.unattributedAssistantContentSchema = require_data_service.unattributedAssistantContentSchema;
 exports.updateResourcePermissionsRequestSchema = require_data_service.updateResourcePermissionsRequestSchema;
 exports.updateResourcePermissionsResponseSchema = require_data_service.updateResourcePermissionsResponseSchema;
+exports.updateSchedulePayloadSchema = updateSchedulePayloadSchema;
 exports.useToast = useToast;
+exports.userSubmittedMessageFieldPathSchema = require_data_service.userSubmittedMessageFieldPathSchema;
 exports.utils = utils;
 exports.validateActionDomain = validateActionDomain;
 exports.validateAndParseOpenAPISpec = validateAndParseOpenAPISpec;