librechat-data-provider 0.8.522 → 0.8.524

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_data_service = require("./data-service-D5kHzBt-.js");
+const require_data_service = require("./data-service-CUG1qdeC.js");
 let zod = require("zod");
 let dayjs = require("dayjs");
 dayjs = require_data_service.__toESM(dayjs);
@@ -15,13 +15,18 @@ let crypto = require("crypto");
 crypto = require_data_service.__toESM(crypto);
 let js_yaml = require("js-yaml");
 //#region src/bedrock.ts
+const THINKING_BINDING_BETA = "thinking-binding-controls-2026-08-01";
 const DEFAULT_THINKING_BUDGET = 2e3;
 const BEDROCK_CLAUDE_SONNET_4_6_MAX_OUTPUT = 64e3;
 const BEDROCK_OUTPUT_128K_BETA = "output-128k-2025-02-19";
 const BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
 /** Betas LibreChat injects itself, safe to strip from persisted AMRF when a
 * model no longer supports them; anything else in `anthropic_beta` is a user opt-in. */
-const GENERATED_BEDROCK_BETAS = new Set([BEDROCK_OUTPUT_128K_BETA, BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA]);
+const GENERATED_BEDROCK_BETAS = new Set([
+	BEDROCK_OUTPUT_128K_BETA,
+	BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA,
+	THINKING_BINDING_BETA
+]);
 const bedrockReasoningConfigValues = new Set(Object.values(require_data_service.BedrockReasoningConfig));
 /**
 * Resolves the final `thinking.display` value for an adaptive-thinking request.
@@ -65,6 +70,13 @@ function parseOpusVersion(model) {
 	};
 	return null;
 }
+/** Opus 5.5 has an always-on, conversation-bound thinking contract unlike Opus 5. */
+function isOpus55Model(model) {
+	const opus = parseOpusVersion(model);
+	return opus?.major === 5 && opus.minor === 5;
+}
+/** LibreChat permits edits and compaction of earlier turns; drop only invalidated blocks. */
+const OPUS_55_BLOCK_BINDING = { prefix_mismatch_behavior: "drop_block" };
 /** Extracts sonnet major/minor version from both naming formats.
 *  Uses bounded minor capture to avoid matching date suffixes (e.g., -20250514). */
 function parseSonnetVersion(model) {
@@ -133,6 +145,7 @@ function omitsSamplingParameters(model) {
 * See https://platform.claude.com/docs/en/about-claude/models/migration-guide#migrating-to-claude-sonnet-5
 */
 function requiresExplicitThinkingDisabled(model) {
+	if (isOpus55Model(model)) return false;
 	const sonnet = parseSonnetVersion(model);
 	if (sonnet != null && sonnet.major >= 5) return true;
 	const opus = parseOpusVersion(model);
@@ -150,6 +163,7 @@ const EFFORTS_REJECTED_WHEN_THINKING_DISABLED = new Set(["xhigh", "max"]);
 * off, so the cap is Opus 5+ only.
 */
 function capsEffortWhenThinkingDisabled(model) {
+	if (isOpus55Model(model)) return false;
 	const opus = parseOpusVersion(model);
 	return opus != null && opus.major >= 5;
 }
@@ -222,6 +236,7 @@ function isBedrockClaudeModel(model) {
 * @returns Array of beta header strings, or empty array if not applicable
 */
 function getBedrockAnthropicBetaHeaders(model) {
+	if (isOpus55Model(model)) return [THINKING_BINDING_BETA];
 	const betaHeaders = [];
 	/** Mythos-class (Fable/Mythos) is intentionally not matched: these betas are built-in/no-op for the
 	* 4.7+ generation (Fable has native 128K output), so omitting them on Bedrock is lossless. */
@@ -369,7 +384,7 @@ const bedrockInputParser = require_data_service.tConversationSchema.pick({
 			/** Persisted AMRF is spread into the final request, so clearing only
 			* `additionalFields` leaves a stale value from a prior selection. */
 			const persistedAmrf = typedData.additionalModelRequestFields;
-			const thinkingDisabled = additionalFields.thinking === false;
+			const thinkingDisabled = additionalFields.thinking === false && !isOpus55Model(typedData.model);
 			const effort = additionalFields.effort;
 			if (typeof effort === "string" && effort !== "") additionalFields.output_config = { effort };
 			else if (effort !== void 0 && persistedAmrf)
@@ -385,7 +400,7 @@ const bedrockInputParser = require_data_service.tConversationSchema.pick({
 			* `effort`, so the branch above leaves it untouched).
 			*/
 			if (thinkingDisabled) [additionalFields, persistedAmrf].forEach((target) => clampOutputConfigEffort(typedData.model, target?.output_config));
-			if (additionalFields.thinking === false) {
+			if (thinkingDisabled) {
 				delete additionalFields.thinkingBudget;
 				delete additionalFields.thinkingDisplay;
 				if (requiresExplicitThinkingDisabled(typedData.model)) additionalFields.thinking = { type: "disabled" };
@@ -407,6 +422,7 @@ const bedrockInputParser = require_data_service.tConversationSchema.pick({
 				const topLevelDisplay = additionalFields.thinkingDisplay;
 				const persistedDisplay = extractPersistedDisplay(typedData.additionalModelRequestFields);
 				const thinkingConfig = { type: "adaptive" };
+				if (isOpus55Model(typedData.model)) thinkingConfig.block_binding = { ...OPUS_55_BLOCK_BINDING };
 				const display = resolveThinkingDisplay(typedData.model, topLevelDisplay ?? persistedDisplay);
 				if (display) thinkingConfig.display = display;
 				additionalFields.thinking = thinkingConfig;
@@ -711,6 +727,10 @@ let ReasoningLabelEvents = /* @__PURE__ */ function(ReasoningLabelEvents) {
 	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`
@@ -722,37 +742,114 @@ let ReasoningLabelEvents = /* @__PURE__ */ function(ReasoningLabelEvents) {
 * 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);
@@ -993,6 +1090,45 @@ function replaceSpecialVars({ text, user, now: inputNow, timezone }) {
 function getEphemeralSender({ modelLabel, specLabel, modelDisplayLabel }) {
 	return modelLabel ?? specLabel ?? modelDisplayLabel ?? "";
 }
+/** Built-in endpoints; anything else in `endpoint` is a custom endpoint's own name. */
+const builtInEndpoints = new Set(Object.values(require_data_service.EModelEndpoint));
+/**
+* Whether a persisted `sender` is a label someone configured rather than the
+* model-derived name `getResponseSender` produces.
+*
+* The sender is the one thing that records which it was: `resolveSender` writes an
+* agent's name, then the `getEphemeralSender` chain (`modelLabel` → a model spec's
+* `label` → an endpoint's `modelDisplayLabel`), and falls back to `getResponseSender`
+* only when none of those is set. Asking the message rather than the conversation
+* settles three things a settings lookup cannot: labels that live in config a caller
+* may not hold, labels an endpoint ignores (Anthropic keeps reading `Claude` whatever
+* `chatGptLabel` says, and matches here), and labels changed since the message was
+* written — its header still shows the sender it was written under.
+*
+* Equality is the test, so the only way to be wrong is a stored name that no longer
+* matches what the current heuristics produce, which withholds a model rather than
+* revealing one.
+*/
+const isConfiguredSender = ({ sender, endpoint, endpointType, model, isCreatedByUser }) => {
+	/** A user turn is headed by the person who wrote it, so it has no model to withhold
+	*  and its `User` sender would never match a derived name. */
+	if (isCreatedByUser === true) return false;
+	/** Agents and assistants are named by whoever authored them: the header shows that
+	*  name whether or not the response stored a sender, and `getResponseSender` has no
+	*  branch to derive one. */
+	if (require_data_service.isAgentsEndpoint(endpoint) || require_data_service.isAssistantsEndpoint(endpoint)) return true;
+	if (sender == null || sender === "") return false;
+	const derived = getResponseSender({
+		endpoint,
+		endpointType: endpointType ?? (endpoint != null && !builtInEndpoints.has(endpoint) ? "custom" : void 0),
+		model
+	});
+	/** An endpoint this cannot name — an older message stored without one, say — says
+	*  nothing either way, and reading that silence as "configured" would withhold the
+	*  model from every unlabelled row it reached. */
+	if (derived === "") return false;
+	return sender !== derived;
+};
 /**
 * 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.
@@ -1285,6 +1421,20 @@ function mapGroupToAzureConfig({ groupName, groupMap }) {
 	return result;
 }
 //#endregion
+//#region src/footer.ts
+/**
+* Whether a deployment configured footer content of its own — a custom footer,
+* a privacy policy or terms of service.
+*
+* The footer bar is absolutely positioned in a zero-height wrapper, so the
+* composer above it is what reserves its band: this answer decides both the
+* bar and the clearance. The client and the server share it because the two
+* answering differently is exactly the layout correction it exists to remove.
+*/
+function hasConfiguredFooter(source) {
+	return typeof source?.customFooter === "string" || source?.interface?.privacyPolicy?.externalUrl != null || source?.interface?.termsOfService?.externalUrl != null;
+}
+//#endregion
 //#region src/langchain.ts
 /**
 * LangChain classifies a provider failure by mutating the error: it stamps `lc_error_code` and
@@ -1375,6 +1525,298 @@ function parseLangChainErrorCode(message) {
 	}
 }
 //#endregion
+//#region src/codeEnvRef.ts
+/**
+* Closed set of resource kinds for sandbox file caching. Defined as a
+* `as const` tuple so the runtime list and the TypeScript union can't
+* drift on future additions — adding a new kind to the tuple updates
+* both at once.
+*
+* - `skill`: shared per skill identity. Cross-user-within-tenant
+*   sharing. Code API sessionKey omits the user dimension.
+*   `version` is required (the skill's monotonic counter scopes the
+*   cache per revision so any edit invalidates the prior cache
+*   entry naturally).
+* - `agent`: shared per agent identity. Same sharing semantic as
+*   skills (agents are addressable resources accessible to a
+*   permission-defined audience).
+* - `user`: user-private. Code API sessionKey is keyed by the
+*   requesting user from auth context. Used for chat attachments
+*   and code-output artifacts.
+*/
+const CODE_ENV_KINDS = [
+	"skill",
+	"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/resolve-llm-delivery-path.ts
+/**
+* The native provider a custom endpoint declares, when it declares one. A custom endpoint
+* speaks OpenAI's API unless its config names another dialect, and the upload route needs
+* that answer for the same reason request initialization does: the media encoders emit
+* OpenAI-format parts, so a custom endpoint running as Anthropic receives none.
+*/
+function getCustomEndpointProvider(customEndpoints, endpoint) {
+	if (!customEndpoints || !endpoint) return;
+	const normalized = require_data_service.normalizeEndpointName(endpoint);
+	return customEndpoints.find((config) => require_data_service.normalizeEndpointName(config.name ?? "") === normalized)?.provider;
+}
+/** A custom endpoint emits OpenAI-format media parts only for the types the admin listed
+*  in its `supportedMimeTypes`; the inherited default list is not an opt-in. A name that
+*  is not a known provider is a custom endpoint. Mirrors `isConfiguredProviderMediaType`
+*  on the encoder side, so the route and the encoder agree on which uploads the provider
+*  actually receives; the built-in endpoints are left out because the client offers no
+*  media for them. */
+const isConfiguredMediaEndpoint = (mimeType, endpoint, supportedMimeTypes) => {
+	if (!require_data_service.isExplicitMimeConfig(supportedMimeTypes) || require_data_service.isKnownProviderIdentifier(endpoint)) return false;
+	return require_data_service.fileConfig.checkType(mimeType, supportedMimeTypes);
+};
+/** 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, supportedMimeTypes) => {
+	if (mimeType.startsWith("audio/") || mimeType.startsWith("video/")) return require_data_service.isMediaSupportedProvider(endpoint) || isConfiguredMediaEndpoint(mimeType, endpoint, supportedMimeTypes);
+	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, supportedMimeTypes) {
+	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, supportedMimeTypes)) 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, endpointProvider, useResponsesApi, sttConfigured }) {
+	if (endpointConfig?.legacyFileUploadUX === true) return "provider";
+	const runsAsOpenAI = endpointProvider == null || require_data_service.isOpenAILikeProvider(endpointProvider);
+	return resolveDefaultLLMDeliveryPath(mimeType, endpointConfig?.defaultLLMDeliveryPath, fileConfig?.defaultLLMDeliveryPath, endpoint, useResponsesApi, sttConfigured, runsAsOpenAI ? endpointConfig?.supportedMimeTypes : void 0);
+}
+/** Delivery path for an upload, honoring an explicitly chosen tool resource. */
+function resolveUploadLLMDeliveryPath({ toolResource, mimeType, endpointConfig, fileConfig, endpoint, useResponsesApi, endpointProvider, sttConfigured }) {
+	if (toolResource === "context" || toolResource === "ocr") return "text";
+	if (toolResource === "file_search" || toolResource === "execute_code") return "none";
+	return resolveDefaultUploadLLMDeliveryPath({
+		mimeType,
+		endpointConfig,
+		fileConfig,
+		endpoint,
+		endpointProvider,
+		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));
+/**
+* Whether the record shows this file reached a tool's own store: vectors for file search, a
+* sandbox pointer for code execution. Nothing else writes either, so their presence is proof
+* the file was provisioned and their absence proof it was not. The same evidence deferred
+* provisioning reads before queueing a file, so a turn cannot withhold content for a tool that
+* provisioning has yet to serve.
+*/
+function hasToolResourceProvisioning(file, toolResource) {
+	if (toolResource === "execute_code") return getCodeEnvRefs(file.metadata).length > 0;
+	return file.embedded === true || (file.metadata?.embeddedEntities?.length ?? 0) > 0;
+}
+/**
+* Whether a tool this turn runs can read a file of this type.
+*
+* Passing the record asks the stricter question a delivery decision needs where a tool serves
+* only what it already holds. File search reads the vector store, and an upload that named no
+* destination is filed under no tool at all, so an enabled search tool is a reader only once
+* the record shows the store holds the file. Run Code needs no copy in advance: its first call
+* uploads every attachment it can read to the sandbox, so enabling it is enough. Requiring a
+* copy there would hand the file's text to the prompt on every turn before the first code run,
+* and a turn that refuses that text never runs code, so the file would never become held.
+*/
+function hasTurnFileConsumer(mimeType, consumers, file) {
+	const searchHolds = file == null || hasToolResourceProvisioning(file, "file_search");
+	return consumers.executeCode && canToolResourceConsume("execute_code", mimeType) || consumers.fileSearch && canToolResourceConsume("file_search", mimeType) && searchHolds;
+}
+const isLLMDeliveryPath = (value) => value === "provider" || value === "text" || value === "none";
+/** Whether a record's stored route was inferred at upload, so each turn resolves it again. */
+function hasInferredLLMDeliveryPath(file) {
+	return file.llmDeliveryPath != null && file.metadata?.destinationChosen !== true;
+}
+/**
+* Delivery path for one attachment on one agent's turn.
+*
+* A record predating routing and a destination the user chose keep what they stored. An
+* inferred route re-resolves against the endpoint handling the turn. A `none` route leaves
+* the file for a tool; where the endpoint enables `textFallbackWithoutTools` and no tool this
+* turn runs can read the file, the text extracted at upload is delivered rather than the file
+* reaching nothing. Consumers left undefined are unknown and not judged, as in
+* {@link resolveUploadDestination}.
+*
+* For file search, reading is asked of the record rather than of the tool set, because the two
+* disagree for the upload that needs the fallback most: one that named no destination is filed
+* under no tool, so enabling file search would otherwise withhold the text for a vector store
+* that never received the file. Run Code is judged by the tool set: see
+* {@link hasTurnFileConsumer}.
+*/
+function resolveTurnLLMDeliveryPath(routing, file, consumers) {
+	if (routing == null || !hasInferredLLMDeliveryPath(file)) return isLLMDeliveryPath(file.llmDeliveryPath) ? file.llmDeliveryPath : void 0;
+	const { endpointConfig } = routing;
+	const mimeType = file.metadata?.routingMimeType ?? file.type ?? "";
+	const path = resolveUploadLLMDeliveryPath({
+		mimeType,
+		...routing
+	});
+	const hasFallbackText = typeof file.text === "string" && file.text.length > 0;
+	if (path === "none" && endpointConfig?.textFallbackWithoutTools === true && consumers != null && hasFallbackText && !hasTurnFileConsumer(mimeType, consumers, file)) return "text";
+	return path;
+}
+/**
+* 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
@@ -1463,6 +1905,73 @@ function buildTree({ messages, fileMap }) {
 	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:
+* `markCompactionOutcome` sets `initiatedBy: 'user'` on whichever part carries
+* the outcome — the summary a Compact action produced, or the error part a run
+* that produced none recorded instead — 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.
+*
+* Compactions stored before the marker existed carry none, so callers keep
+* their own ancestry test as the fallback.
+*/
+function isUserInitiatedCompaction(message) {
+	const content = message?.content;
+	if (!Array.isArray(content)) return false;
+	return content.some((part) => (part?.type === "summary" || part?.type === "error") && 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;
+		/** No `boundary` means the round never completed: only the final summary
+		*  block carries one, so a part holding streamed deltas alone lacks it. */
+		if (part.summarizing === true || part.failed === true || part.boundary == null) 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
 /**
@@ -5095,6 +5604,28 @@ let InvocationMode = /* @__PURE__ */ function(InvocationMode) {
 	return InvocationMode;
 }({});
 //#endregion
+//#region src/types/content.ts
+let AnnotationTypes = /* @__PURE__ */ function(AnnotationTypes) {
+	AnnotationTypes["FILE_CITATION"] = "file_citation";
+	AnnotationTypes["FILE_PATH"] = "file_path";
+	return AnnotationTypes;
+}({});
+let StepStatus = /* @__PURE__ */ function(StepStatus) {
+	StepStatus["IN_PROGRESS"] = "in_progress";
+	StepStatus["CANCELLED"] = "cancelled";
+	StepStatus["FAILED"] = "failed";
+	StepStatus["COMPLETED"] = "completed";
+	StepStatus["EXPIRED"] = "expired";
+	return StepStatus;
+}({});
+let MessageContentTypes = /* @__PURE__ */ function(MessageContentTypes) {
+	MessageContentTypes["TEXT"] = "text";
+	MessageContentTypes["IMAGE_FILE"] = "image_file";
+	return MessageContentTypes;
+}({});
+const hostImageIdSuffix = "_host_copy";
+const hostImageNamePrefix = "host_copy_";
+//#endregion
 //#region src/types/schedules.ts
 /** Cadences the dialog builds from structured pickers (hour, minute, weekday). */
 const scheduleStructuredFrequencies = [
@@ -5161,6 +5692,35 @@ const updateSchedulePayloadSchema = createSchedulePayloadSchema.omit({ clientReq
 * 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`. */
@@ -5433,6 +5993,12 @@ let DATE_RANGE = /* @__PURE__ */ function(DATE_RANGE) {
 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 = [
@@ -5450,7 +6016,12 @@ const agentQueuedTurnFileRefSchema = zod.z.object({
 	filename: zod.z.string().optional(),
 	height: zod.z.number().optional(),
 	width: zod.z.number().optional(),
-	bytes: zod.z.number().nonnegative().optional()
+	bytes: zod.z.number().nonnegative().optional(),
+	llmDeliveryPath: zod.z.enum([
+		"provider",
+		"text",
+		"none"
+	]).optional()
 });
 const enqueueAgentQueuedTurnSchema = zod.z.object({
 	conversationId: zod.z.string().trim().min(1),
@@ -5519,6 +6090,7 @@ let ProviderId = /* @__PURE__ */ function(ProviderId) {
 	ProviderId["groq"] = "groq";
 	ProviderId["helicone"] = "helicone";
 	ProviderId["huggingface"] = "huggingface";
+	ProviderId["lemonade"] = "lemonade";
 	ProviderId["mistral"] = "mistral";
 	ProviderId["mlx"] = "mlx";
 	ProviderId["ollama"] = "ollama";
@@ -5548,6 +6120,7 @@ const knownEndpointToProvider = {
 	["groq"]: "groq",
 	["helicone"]: "helicone",
 	["huggingface"]: "huggingface",
+	["lemonade"]: "lemonade",
 	["mistral"]: "mistral",
 	["mlx"]: "mlx",
 	["ollama"]: "ollama",
@@ -5573,6 +6146,8 @@ const providerAliases = {
 	grok: "xai",
 	kimi: "moonshot",
 	moonshotai: "moonshot",
+	amdlemonade: "lemonade",
+	lemonadeserver: "lemonade",
 	mistralai: "mistral",
 	togetherai: "together"
 };
@@ -5594,6 +6169,77 @@ function resolveModelCatalogKey(provider, catalogs) {
 	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");
@@ -6077,7 +6723,7 @@ 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;
@@ -6091,12 +6737,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,
@@ -7279,6 +7931,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
@@ -7347,8 +8031,50 @@ const agentParamSettings = Object.entries(presetSettings).reduce((acc, [key, val
 * 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) {
+function applyModelAwareDefaults(settings, endpoint, model, responsesApiRouting) {
 	if (!model) return settings;
+	if (/^grok-4[.-]7(?:$|[-:])/.test(model.split("/").pop() ?? "")) return settings.map((setting) => setting.key === "reasoning_effort" ? {
+		...setting,
+		options: [
+			"",
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		]
+	} : setting);
+	if (/^gpt-6-(?:sol|luna)(?:$|-)/i.test(model)) return settings.map((setting) => {
+		if (setting.key === "reasoning_effort") return {
+			...setting,
+			options: setting.options?.filter((effort) => effort !== "minimal")
+		};
+		/** Match the native backend's unset default without writing into stored
+		* settings. Explicit false still overrides this rendered default. */
+		if (setting.key === "useResponsesApi") {
+			const route = (value) => require_data_service.resolveEffectiveUseResponsesApi({
+				endpoint,
+				model,
+				routing: responsesApiRouting,
+				value
+			});
+			return {
+				...setting,
+				default: route() ?? false,
+				enumMappings: {
+					true: route(true) ?? true,
+					false: route(false) ?? false
+				}
+			};
+		}
+		return setting;
+	});
+	if (isOpus55Model(model)) return settings.filter((setting) => ![
+		"thinking",
+		"thinkingBudget",
+		"temperature",
+		"topP",
+		"topK"
+	].includes(setting.key));
 	const modelAwareSettings = endpoint === "google" ? settings.map((setting) => {
 		if (setting.key === "maxOutputTokens") return {
 			...setting,
@@ -7412,64 +8138,50 @@ function removeCodeExecutionCaller(toolOptions) {
 	return normalized;
 }
 //#endregion
-//#region src/codeEnvRef.ts
-/**
-* Closed set of resource kinds for sandbox file caching. Defined as a
-* `as const` tuple so the runtime list and the TypeScript union can't
-* drift on future additions — adding a new kind to the tuple updates
-* both at once.
-*
-* - `skill`: shared per skill identity. Cross-user-within-tenant
-*   sharing. Code API sessionKey omits the user dimension.
-*   `version` is required (the skill's monotonic counter scopes the
-*   cache per revision so any edit invalidates the prior cache
-*   entry naturally).
-* - `agent`: shared per agent identity. Same sharing semantic as
-*   skills (agents are addressable resources accessible to a
-*   permission-defined audience).
-* - `user`: user-private. Code API sessionKey is keyed by the
-*   requesting user from auth context. Used for chat attachments
-*   and code-output artifacts.
-*/
-const CODE_ENV_KINDS = [
-	"skill",
-	"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;
+//#region src/backgroundResults.ts
+/** Shared serialized metadata shape for admission budgeting and continuation rendering. */
+function backgroundResultMetadata(result) {
 	return {
-		codeEnvRef: codeEnvRefs.default ?? codeEnvRefs.stateful ?? ref,
-		codeEnvRefs
+		background_task_id: result.taskId,
+		tool_call_id: result.toolCallId,
+		tool: result.toolName,
+		status: result.status,
+		result: ""
 	};
 }
-/** 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_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_DEFAULT = require_data_service.AGENT_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_DEFAULT;
+exports.AGENT_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_HARD_MAX = require_data_service.AGENT_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_HARD_MAX;
 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;
 exports.ActivityLabelEvents = ActivityLabelEvents;
 exports.AgentCapabilities = require_data_service.AgentCapabilities;
-exports.AnnotationTypes = require_data_service.AnnotationTypes;
+exports.AnnotationTypes = AnnotationTypes;
 exports.AnthropicEffort = require_data_service.AnthropicEffort;
 exports.ApprovalEvents = ApprovalEvents;
 exports.ArtifactModes = ArtifactModes;
@@ -7484,17 +8196,39 @@ 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_ENVIRONMENT_MOVE_VERSION = require_data_service.CODE_ENVIRONMENT_MOVE_VERSION;
+exports.CODE_ENVIRONMENT_QUEUE_WAIT_DEFAULT_MS = require_data_service.CODE_ENVIRONMENT_QUEUE_WAIT_DEFAULT_MS;
 exports.CODE_ENV_KINDS = CODE_ENV_KINDS;
+exports.CODE_WORKSPACE_ID_PATTERN = require_data_service.CODE_WORKSPACE_ID_PATTERN;
+exports.CODE_WORKSPACE_INSTANCE_TYPES = require_data_service.CODE_WORKSPACE_INSTANCE_TYPES;
+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_AGENT_MODEL_RESPONSE_BODY_TIMEOUT_MS = require_data_service.DEFAULT_AGENT_MODEL_RESPONSE_BODY_TIMEOUT_MS;
+exports.DEFAULT_AGENT_MODEL_RESPONSE_HEADERS_TIMEOUT_MS = require_data_service.DEFAULT_AGENT_MODEL_RESPONSE_HEADERS_TIMEOUT_MS;
+exports.DEFAULT_BALANCE_RESERVATION_TTL_MS = require_data_service.DEFAULT_BALANCE_RESERVATION_TTL_MS;
+exports.DEFAULT_MAX_PROVIDER_ERROR_CHARS = require_data_service.DEFAULT_MAX_PROVIDER_ERROR_CHARS;
+exports.DEFAULT_MAX_RETAINED_TOOL_COUNT_CHARS = require_data_service.DEFAULT_MAX_RETAINED_TOOL_COUNT_CHARS;
 exports.DEFAULT_MEMORY_MAX_INPUT_TOKENS = require_data_service.DEFAULT_MEMORY_MAX_INPUT_TOKENS;
+exports.DEFAULT_OAUTH_STATE_TTL_MS = require_data_service.DEFAULT_OAUTH_STATE_TTL_MS;
+exports.DEFAULT_RETAINED_ANSWER_TOKENS = require_data_service.DEFAULT_RETAINED_ANSWER_TOKENS;
+exports.DEFAULT_SKILL_IMPORT_CLEANUP_CONCURRENCY = require_data_service.DEFAULT_SKILL_IMPORT_CLEANUP_CONCURRENCY;
+exports.DefaultLLMDeliveryPath = require_data_service.DefaultLLMDeliveryPath;
 exports.DynamicQueryKeys = require_data_service.DynamicQueryKeys;
 exports.EImageOutputType = require_data_service.EImageOutputType;
 exports.EModelEndpoint = require_data_service.EModelEndpoint;
@@ -7514,6 +8248,7 @@ 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;
@@ -7524,10 +8259,15 @@ 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_MCP_OAUTH_PERSISTENCE_WAIT_MS = require_data_service.MAX_MCP_OAUTH_PERSISTENCE_WAIT_MS;
 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;
@@ -7548,13 +8288,15 @@ 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_BALANCE_RESERVATION_TTL_MS = require_data_service.MIN_BALANCE_RESERVATION_TTL_MS;
 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;
+exports.MessageContentTypes = MessageContentTypes;
 exports.MutationKeys = require_data_service.MutationKeys;
 exports.OCRStrategy = require_data_service.OCRStrategy;
+exports.OPUS_55_BLOCK_BINDING = OPUS_55_BLOCK_BINDING;
 exports.OptionTypes = require_data_service.OptionTypes;
 exports.PERMISSION_SUB_KEYS = PERMISSION_SUB_KEYS;
 exports.PERMISSION_TYPE_INTERFACE_FIELDS = PERMISSION_TYPE_INTERFACE_FIELDS;
@@ -7598,6 +8340,8 @@ 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;
@@ -7609,12 +8353,16 @@ exports.SkillsScope = require_data_service.SkillsScope;
 exports.StdioOptionsSchema = require_data_service.StdioOptionsSchema;
 exports.SteerEvents = SteerEvents;
 exports.StepEvents = StepEvents;
-exports.StepStatus = require_data_service.StepStatus;
+exports.StepStatus = StepStatus;
 exports.StepTypes = StepTypes;
 exports.StreamableHTTPOptionsSchema = require_data_service.StreamableHTTPOptionsSchema;
 exports.SystemCategories = require_data_service.SystemCategories;
 exports.SystemRoles = SystemRoles;
+exports.THINKING_BINDING_BETA = THINKING_BINDING_BETA;
 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;
@@ -7633,6 +8381,7 @@ 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;
@@ -7657,6 +8406,8 @@ exports.apiBaseUrl = require_data_service.apiBaseUrl;
 exports.appendAgentIdSuffix = appendAgentIdSuffix;
 exports.applicationMimeTypes = require_data_service.applicationMimeTypes;
 exports.applyModelAwareDefaults = applyModelAwareDefaults;
+exports.askUserQuestionConfigSchema = require_data_service.askUserQuestionConfigSchema;
+exports.askUserQuestionRetainedAnswersSchema = require_data_service.askUserQuestionRetainedAnswersSchema;
 exports.assistantEndpointSchema = require_data_service.assistantEndpointSchema;
 exports.assistantSchema = require_data_service.assistantSchema;
 exports.audioMimeTypes = require_data_service.audioMimeTypes;
@@ -7666,6 +8417,7 @@ exports.azureBaseSchema = require_data_service.azureBaseSchema;
 exports.azureEndpointSchema = require_data_service.azureEndpointSchema;
 exports.azureGroupConfigsSchema = require_data_service.azureGroupConfigsSchema;
 exports.azureGroupSchema = require_data_service.azureGroupSchema;
+exports.backgroundResultMetadata = backgroundResultMetadata;
 exports.badge = badge;
 exports.balanceSchema = require_data_service.balanceSchema;
 exports.baseEndpointSchema = require_data_service.baseEndpointSchema;
@@ -7688,6 +8440,7 @@ 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;
@@ -7718,6 +8471,7 @@ 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;
@@ -7733,6 +8487,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;
@@ -7792,16 +8547,21 @@ exports.filterPiiCustomPatternSchema = require_data_service.filterPiiCustomPatte
 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.getCustomEndpointProvider = getCustomEndpointProvider;
 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;
@@ -7817,6 +8577,7 @@ 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;
@@ -7829,10 +8590,16 @@ 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.hasConfiguredFooter = hasConfiguredFooter;
+exports.hasInferredLLMDeliveryPath = hasInferredLLMDeliveryPath;
 exports.hasPermissions = require_data_service.hasPermissions;
 exports.hasProcessMCPServerConfig = require_data_service.hasProcessMCPServerConfig;
-exports.hostImageIdSuffix = require_data_service.hostImageIdSuffix;
-exports.hostImageNamePrefix = require_data_service.hostImageNamePrefix;
+exports.hasTextExtractionPath = hasTextExtractionPath;
+exports.hasToolCallErrorPrefix = hasToolCallErrorPrefix;
+exports.hasToolResourceProvisioning = hasToolResourceProvisioning;
+exports.hasTurnFileConsumer = hasTurnFileConsumer;
+exports.hostImageIdSuffix = hostImageIdSuffix;
+exports.hostImageNamePrefix = hostImageNamePrefix;
 exports.hoverCard = hoverCard;
 exports.imageDetailNumeric = require_data_service.imageDetailNumeric;
 exports.imageDetailValue = require_data_service.imageDetailValue;
@@ -7851,37 +8618,59 @@ 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.isCodeWorkspaceEnvironment = require_data_service.isCodeWorkspaceEnvironment;
+exports.isCodeWorkspaceSelection = require_data_service.isCodeWorkspaceSelection;
+exports.isCodeWorkspaceSelectionErrorReason = require_data_service.isCodeWorkspaceSelectionErrorReason;
+exports.isCodeWorkspaceSelections = require_data_service.isCodeWorkspaceSelections;
+exports.isCompactedLeaf = isCompactedLeaf;
+exports.isConfiguredSender = isConfiguredSender;
 exports.isCronCadence = isCronCadence;
 exports.isDocumentSupportedProvider = require_data_service.isDocumentSupportedProvider;
 exports.isEphemeralAgentId = isEphemeralAgentId;
+exports.isExplicitMimeConfig = require_data_service.isExplicitMimeConfig;
 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.isOpus55Model = isOpus55Model;
 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.isRepositoryInstructionDescriptor = require_data_service.isRepositoryInstructionDescriptor;
+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;
@@ -7911,9 +8700,11 @@ exports.omitsThinkingByDefault = omitsThinkingByDefault;
 exports.openAIBaseSchema = require_data_service.openAIBaseSchema;
 exports.openAISchema = require_data_service.openAISchema;
 exports.openAISettings = require_data_service.openAISettings;
+exports.openIdDiscoverySchema = require_data_service.openIdDiscoverySchema;
 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;
@@ -7926,8 +8717,10 @@ exports.parseTextParts = parseTextParts;
 exports.peoplePickerPermissionsSchema = peoplePickerPermissionsSchema;
 exports.permBitsToAccessLevel = require_data_service.permBitsToAccessLevel;
 exports.permissionEntrySchema = require_data_service.permissionEntrySchema;
+exports.permissionWriteAttemptsSchema = require_data_service.permissionWriteAttemptsSchema;
 exports.permissionsSchema = permissionsSchema;
 exports.popover = popover;
+exports.prefersResponsesApiByModel = require_data_service.prefersResponsesApiByModel;
 exports.presetSettings = presetSettings;
 exports.principalSchema = require_data_service.principalSchema;
 exports.progress = progress;
@@ -7937,7 +8730,9 @@ 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;
@@ -7947,14 +8742,27 @@ 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.resolveEffectiveUseResponsesApi = require_data_service.resolveEffectiveUseResponsesApi;
 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.resolveTurnLLMDeliveryPath = resolveTurnLLMDeliveryPath;
+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;
@@ -7963,6 +8771,7 @@ exports.roleSchema = roleSchema;
 exports.runCodePermissionsSchema = runCodePermissionsSchema;
 exports.scheduleCadenceSchema = scheduleCadenceSchema;
 exports.scheduleFrequencies = scheduleFrequencies;
+exports.scheduleMCPOutcomeSchema = scheduleMCPOutcomeSchema;
 exports.scheduleStructuredFrequencies = scheduleStructuredFrequencies;
 exports.scheduleTargets = scheduleTargets;
 exports.schedulesPermissionsSchema = schedulesPermissionsSchema;
@@ -7992,6 +8801,7 @@ 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;
@@ -8031,6 +8841,8 @@ 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;