librechat-data-provider 0.8.509 → 0.8.522

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_data_service = require("./data-service-XTxx76uB.js");
+const require_data_service = require("./data-service-D5kHzBt-.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");
@@ -14,10 +15,13 @@ let crypto = require("crypto");
 crypto = require_data_service.__toESM(crypto);
 let js_yaml = require("js-yaml");
 //#region src/bedrock.ts
-const DEFAULT_ENABLED_MAX_TOKENS = 8192;
 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 bedrockReasoningConfigValues = new Set(Object.values(require_data_service.BedrockReasoningConfig));
 /**
 * Resolves the final `thinking.display` value for an adaptive-thinking request.
@@ -62,14 +66,14 @@ function parseOpusVersion(model) {
 	return null;
 }
 /** Extracts sonnet major/minor version from both naming formats.
-*  Uses single-digit minor capture to avoid matching date suffixes (e.g., -20250514). */
+*  Uses bounded minor capture to avoid matching date suffixes (e.g., -20250514). */
 function parseSonnetVersion(model) {
-	const nameFirst = model.match(/claude-sonnet[-.]?(\d+)(?:[-.](\d)(?!\d))?/);
+	const nameFirst = model.match(/claude-sonnet[-.]?(\d+)(?:[-.](\d{1,2})(?!\d))?/);
 	if (nameFirst) return {
 		major: parseInt(nameFirst[1], 10),
 		minor: nameFirst[2] != null ? parseInt(nameFirst[2], 10) : 0
 	};
-	const numFirst = model.match(/claude-(\d+)(?:[-.](\d)(?!\d))?-sonnet/);
+	const numFirst = model.match(/claude-(\d+)(?:[-.](\d{1,2})(?!\d))?-sonnet/);
 	if (numFirst) return {
 		major: parseInt(numFirst[1], 10),
 		minor: numFirst[2] != null ? parseInt(numFirst[2], 10) : 0
@@ -103,15 +107,80 @@ function supportsAdaptiveThinking(model) {
 function omitsThinkingByDefault(model) {
 	const opus = parseOpusVersion(model);
 	if (opus && (opus.major > 4 || opus.major === 4 && opus.minor >= 7)) return true;
+	const sonnet = parseSonnetVersion(model);
+	if (sonnet != null && sonnet.major >= 5) return true;
 	if (require_data_service.isMythosClassModel(model)) return true;
 	return false;
 }
 function omitsSamplingParameters(model) {
 	const opus = parseOpusVersion(model);
 	if (opus && (opus.major > 4 || opus.major === 4 && opus.minor >= 7)) return true;
+	const sonnet = parseSonnetVersion(model);
+	if (sonnet != null && sonnet.major >= 5) return true;
 	if (require_data_service.isMythosClassModel(model)) return true;
 	return false;
 }
+/**
+* Whether disabling thinking requires sending an explicit `{ type: 'disabled' }`
+* config rather than simply omitting the `thinking` field.
+*
+* Sonnet 5 and Opus 5 treat an omitted `thinking` field as adaptive thinking ON
+* by default, so honoring a user who turns thinking off means sending the
+* disabled config explicitly. Opus 4.7/4.8 run without thinking when the field
+* is omitted, and Fable/Mythos reject an explicit disabled config (400,
+* thinking always on), so both are excluded.
+*
+* See https://platform.claude.com/docs/en/about-claude/models/migration-guide#migrating-to-claude-sonnet-5
+*/
+function requiresExplicitThinkingDisabled(model) {
+	const sonnet = parseSonnetVersion(model);
+	if (sonnet != null && sonnet.major >= 5) return true;
+	const opus = parseOpusVersion(model);
+	return opus != null && opus.major >= 5;
+}
+/** Effort levels Opus 5 rejects while thinking is explicitly disabled. */
+const EFFORTS_REJECTED_WHEN_THINKING_DISABLED = new Set(["xhigh", "max"]);
+/**
+* Whether the model caps `output_config.effort` while thinking is disabled.
+*
+* Opus 5 rejects `xhigh`/`max` in that combination with a 400: "output_config
+* .effort 'xhigh' is not supported when thinking is disabled on this model. Use
+* effort 'high' or below, or enable thinking." Opus 4.7/4.8, Sonnet 5, and
+* Sonnet 4.6 accept every effort level they otherwise support with thinking
+* off, so the cap is Opus 5+ only.
+*/
+function capsEffortWhenThinkingDisabled(model) {
+	const opus = parseOpusVersion(model);
+	return opus != null && opus.major >= 5;
+}
+/**
+* Lowers an effort level the model would reject while thinking is disabled to
+* the highest accepted value (`high`, which is also the API default). Returns
+* the effort unchanged when the combination is valid.
+*/
+function clampEffortForDisabledThinking(model, effort) {
+	if (capsEffortWhenThinkingDisabled(model) && EFFORTS_REJECTED_WHEN_THINKING_DISABLED.has(effort)) return "high";
+	return effort;
+}
+/** An `output_config` container carrying a usable effort level. */
+function hasStringEffort(value) {
+	if (typeof value !== "object" || value === null || !("effort" in value)) return false;
+	return typeof value.effort === "string";
+}
+/**
+* Clamps an `output_config.effort` in place when the model would reject it
+* while thinking is disabled. No-op when the container carries no string
+* effort, so callers can pass a possibly-absent config directly.
+*/
+function clampOutputConfigEffort(model, outputConfig) {
+	if (!hasStringEffort(outputConfig)) return;
+	outputConfig.effort = clampEffortForDisabledThinking(model, outputConfig.effort);
+}
+/** Whether a resolved thinking config is an explicit `{ type: 'disabled' }`. */
+function isThinkingDisabled(thinking) {
+	if (typeof thinking !== "object" || thinking === null || !("type" in thinking)) return false;
+	return thinking.type === "disabled";
+}
 /** Checks if a model has a 1M context window (Sonnet 4.6+, Opus 4.6+, Opus 5+, Fable/Mythos) */
 function supportsContext1m(model) {
 	const sonnet = parseSonnetVersion(model);
@@ -122,6 +191,30 @@ 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).
+* Match on the `claude` family token so every form is recognized — requiring
+* the literal `anthropic.` prefix silently dropped thinking config, beta
+* headers, and sampling handling for inference-profile deployments.
+*/
+const BEDROCK_CLAUDE_4PLUS_THINKING = /claude-(?:[4-9](?:\.\d+)?(?:-\d+)?-(?:sonnet|opus|haiku)|(?:sonnet|opus|haiku)-[4-9])/;
+/** Whether a Bedrock model ID is an Anthropic Claude model (prefixed or bare). */
+function isBedrockClaudeModel(model) {
+	return model.includes("claude");
+}
+/**
 * Gets the appropriate anthropic_beta headers for Bedrock Anthropic models.
 * Bedrock uses `anthropic_beta` (with underscore) in additionalModelRequestFields.
 *
@@ -132,19 +225,33 @@ function getBedrockAnthropicBetaHeaders(model) {
 	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. */
-	const isClaude4PlusModel = /anthropic\.claude-(?:[4-9](?:\.\d+)?(?:-\d+)?-(?:sonnet|opus|haiku)|(?:sonnet|opus|haiku)-[4-9])/.test(model);
-	if (model.includes("anthropic.claude-3-7-sonnet") || isClaude4PlusModel) betaHeaders.push(BEDROCK_OUTPUT_128K_BETA);
+	const isClaude4PlusModel = BEDROCK_CLAUDE_4PLUS_THINKING.test(model);
+	if (model.includes("claude-3-7-sonnet") || isClaude4PlusModel) betaHeaders.push(BEDROCK_OUTPUT_128K_BETA);
 	if (isClaude4PlusModel) betaHeaders.push(BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA);
 	return betaHeaders;
 }
+/** Flatten an anthropic_beta value (array, single string, or comma-delimited
+* string) into trimmed, non-empty header tokens. */
+function normalizeBetaHeaders(value) {
+	let values = [];
+	if (Array.isArray(value)) values = value;
+	else if (typeof value === "string") values = [value];
+	const headers = [];
+	values.forEach((entry) => {
+		if (typeof entry !== "string") return;
+		entry.split(",").map((header) => header.trim()).filter(Boolean).forEach((header) => headers.push(header));
+	});
+	return headers;
+}
 function mergeBedrockAnthropicBetaHeaders(existing, generated) {
-	let existingValues = [];
-	if (Array.isArray(existing)) existingValues = existing;
-	else if (typeof existing === "string") existingValues = [existing];
+	const generatedSet = new Set(generated);
 	const betaHeaders = /* @__PURE__ */ new Set();
-	[...existingValues, ...generated].forEach((value) => {
-		if (typeof value !== "string") return;
-		value.split(",").map((header) => header.trim()).filter(Boolean).forEach((header) => betaHeaders.add(header));
+	[...normalizeBetaHeaders(existing), ...generated].forEach((header) => {
+		/** Drop a generated beta carried over from a prior model that the current
+		* model does not generate (e.g. fine-grained-tool-streaming on a 3.7
+		* profile); user opt-ins are always preserved. */
+		if (GENERATED_BEDROCK_BETAS.has(header) && !generatedSet.has(header)) return;
+		betaHeaders.add(header);
 	});
 	return Array.from(betaHeaders);
 }
@@ -178,7 +285,7 @@ const bedrockInputSchema = require_data_service.tConversationSchema.pick({
 }).transform((obj) => {
 	if (obj.additionalModelRequestFields?.thinking != null) {
 		const thinking = obj.additionalModelRequestFields.thinking;
-		obj.thinking = !!thinking;
+		obj.thinking = typeof thinking === "object" && thinking !== null && thinking.type === "disabled" ? false : !!thinking;
 		obj.thinkingBudget = typeof thinking === "object" && "budget_tokens" in thinking ? thinking.budget_tokens : void 0;
 		if (obj.thinkingDisplay == null) {
 			const persistedDisplay = extractPersistedDisplay({ thinking });
@@ -245,16 +352,49 @@ const bedrockInputParser = require_data_service.tConversationSchema.pick({
 			delete typedData[key];
 		}
 	});
-	/** Configure thinking for Bedrock Anthropic models: 3.7 Sonnet, Claude 4+ (opus/sonnet/haiku), and Mythos-class (Fable/Mythos). */
-	if (typeof typedData.model === "string" && (typedData.model.includes("anthropic.claude-3-7-sonnet") || /anthropic\.claude-(?:[4-9](?:\.\d+)?(?:-\d+)?-(?:sonnet|opus|haiku)|(?:sonnet|opus|haiku)-[4-9])/.test(typedData.model) || require_data_service.isMythosClassModel(typedData.model))) {
+	/**
+	* Persisted `model_parameters` can carry a prior "thinking off" only inside
+	* `additionalModelRequestFields.thinking = { type: 'disabled' }` (a known
+	* key that isn't spread into `additionalFields`). `initializeBedrock` feeds
+	* those params straight through this parser, so surface that as
+	* `thinking: false` — otherwise the disabled branch is skipped and the
+	* config rebuilds adaptive, flipping a user's Sonnet 5 setting back on.
+	*/
+	const persistedThinking = typedData.additionalModelRequestFields?.thinking;
+	if (additionalFields.thinking === void 0 && typeof persistedThinking === "object" && persistedThinking !== null && persistedThinking.type === "disabled") additionalFields.thinking = false;
+	/** Bedrock thinking-capable Claude models: 3.7 Sonnet, Claude 4+ (opus/sonnet/haiku), and Mythos-class (Fable/Mythos). */
+	const isThinkingModel = typeof typedData.model === "string" && (typedData.model.includes("claude-3-7-sonnet") || BEDROCK_CLAUDE_4PLUS_THINKING.test(typedData.model) || require_data_service.isMythosClassModel(typedData.model));
+	if (isThinkingModel) {
 		if (supportsAdaptiveThinking(typedData.model)) {
+			/** 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 effort = additionalFields.effort;
-			if (effort && typeof effort === "string" && effort !== "") additionalFields.output_config = { effort };
+			if (typeof effort === "string" && effort !== "") additionalFields.output_config = { effort };
+			else if (effort !== void 0 && persistedAmrf)
+ /** Explicit unset ('' or null) clears the persisted effort. An absent
+			* effort (agent resume, where the prior llmConfig persisted
+			* `output_config` but no top-level `effort`) preserves it. */
+			delete persistedAmrf.output_config;
 			delete additionalFields.effort;
+			/**
+			* Opus 5 rejects `xhigh`/`max` effort while thinking is disabled, so
+			* clamp both the effort derived above and any effort still carried in
+			* persisted AMRF (agent resume sends `output_config` with no top-level
+			* `effort`, so the branch above leaves it untouched).
+			*/
+			if (thinkingDisabled) [additionalFields, persistedAmrf].forEach((target) => clampOutputConfigEffort(typedData.model, target?.output_config));
 			if (additionalFields.thinking === false) {
-				delete additionalFields.thinking;
 				delete additionalFields.thinkingBudget;
 				delete additionalFields.thinkingDisplay;
+				if (requiresExplicitThinkingDisabled(typedData.model)) additionalFields.thinking = { type: "disabled" };
+				else {
+					delete additionalFields.thinking;
+					/** Disable-by-omission models (Opus 4.7+): drop the persisted
+					* adaptive config so turning thinking off actually disables it. */
+					if (persistedAmrf) delete persistedAmrf.thinking;
+				}
 			} else {
 				/**
 				* Persisted agent `model_parameters` round-trip back through this
@@ -282,10 +422,18 @@ const bedrockInputParser = require_data_service.tConversationSchema.pick({
 			if (additionalFields.thinking === true && additionalFields.thinkingBudget === void 0) additionalFields.thinkingBudget = DEFAULT_THINKING_BUDGET;
 			delete additionalFields.effort;
 			delete additionalFields.thinkingDisplay;
+			/** A bare non-adaptive thinking profile (e.g. `claude-3-7-sonnet`) must
+			* not inherit an adaptive/disabled thinking object or `output_config`
+			* persisted from another model; this branch's own fields are authoritative. */
+			const persistedAmrf = typedData.additionalModelRequestFields;
+			if (persistedAmrf) {
+				delete persistedAmrf.thinking;
+				delete persistedAmrf.output_config;
+			}
 		}
 		/** Anthropic uses 'effort' via output_config, not reasoning_config */
 		delete additionalFields.reasoning_effort;
-		if (typedData.model.includes("anthropic.")) {
+		if (isBedrockClaudeModel(typedData.model)) {
 			const betaHeaders = getBedrockAnthropicBetaHeaders(typedData.model);
 			if (betaHeaders.length > 0) {
 				const existingBetaHeaders = typedData.additionalModelRequestFields?.anthropic_beta;
@@ -303,7 +451,7 @@ const bedrockInputParser = require_data_service.tConversationSchema.pick({
 		delete additionalFields.reasoning_effort;
 		if (typeof reasoningEffort === "string" && bedrockReasoningConfigValues.has(reasoningEffort)) additionalFields.reasoning_config = reasoningEffort;
 	}
-	const isAnthropicModel = typeof typedData.model === "string" && typedData.model.includes("anthropic.");
+	const isAnthropicModel = typeof typedData.model === "string" && isBedrockClaudeModel(typedData.model);
 	/** Strip stale fields from previously-persisted additionalModelRequestFields */
 	if (typeof typedData.additionalModelRequestFields === "object" && typedData.additionalModelRequestFields != null) {
 		const amrf = typedData.additionalModelRequestFields;
@@ -317,6 +465,22 @@ const bedrockInputParser = require_data_service.tConversationSchema.pick({
 		} else {
 			delete amrf.reasoning_config;
 			delete amrf.reasoning_effort;
+			/** A Claude model that does not support Bedrock thinking (e.g. a bare
+			* `claude-3-5-sonnet` inference profile) must not carry stale thinking
+			* fields from a previously-selected thinking model. Drop only the
+			* LibreChat-generated betas (output-128k, fine-grained tool streaming);
+			* user opt-ins in `anthropic_beta` are preserved. */
+			if (!isThinkingModel) {
+				delete amrf.thinking;
+				delete amrf.thinkingBudget;
+				delete amrf.effort;
+				delete amrf.output_config;
+				if (amrf.anthropic_beta !== void 0) {
+					const kept = normalizeBetaHeaders(amrf.anthropic_beta).filter((header) => !GENERATED_BEDROCK_BETAS.has(header));
+					if (kept.length > 0) amrf.anthropic_beta = kept;
+					else delete amrf.anthropic_beta;
+				}
+			}
 		}
 		if (shouldOmitSamplingParameters) {
 			delete amrf.temperature;
@@ -359,11 +523,37 @@ const bedrockInputParser = require_data_service.tConversationSchema.pick({
 * @param data - The parsed Bedrock request options object
 * @returns The object with thinking configured appropriately
 */
+/**
+* `anthropicSettings.maxOutputTokens.reset` only matches the canonical
+* family-first id (`claude-sonnet-5`); Bedrock also accepts number-first
+* aliases (`claude-5-sonnet`, `claude-4-7-sonnet`) that this file gates as
+* thinking models. Canonicalize to family-first so those aliases resolve to the
+* real ceiling instead of the 8192 fallback.
+*/
+function toFamilyFirstClaudeId(model) {
+	return model.replace(/claude-(\d+(?:[-.]\d+)?)-(sonnet|opus|haiku)/, "claude-$2-$1");
+}
+function isBedrockClaudeSonnet46(model) {
+	return /claude-sonnet[-.]?4[-.]?6(?=$|[^0-9])/.test(toFamilyFirstClaudeId(model));
+}
+/**
+* Thinking tokens share the `maxTokens` output budget with tool-call arguments
+* (e.g. a `create_file` `content`), so a low default truncates large authored
+* files mid-argument. Mirror the direct-Anthropic path and default to the
+* model's full max output when the request does not set one explicitly.
+*/
+function resolveThinkingMaxTokens(data) {
+	const explicit = data.maxTokens ?? data.maxOutputTokens;
+	if (typeof explicit === "number" && explicit > 0) return explicit;
+	const model = typeof data.model === "string" ? data.model : "";
+	if (isBedrockClaudeSonnet46(model)) return BEDROCK_CLAUDE_SONNET_4_6_MAX_OUTPUT;
+	return require_data_service.anthropicSettings.maxOutputTokens.reset(toFamilyFirstClaudeId(model));
+}
 function configureThinking(data) {
 	const updatedData = { ...data };
 	const thinking = updatedData.additionalModelRequestFields?.thinking;
 	if (thinking === true) {
-		updatedData.maxTokens = updatedData.maxTokens ?? updatedData.maxOutputTokens ?? DEFAULT_ENABLED_MAX_TOKENS;
+		updatedData.maxTokens = resolveThinkingMaxTokens(updatedData);
 		delete updatedData.maxOutputTokens;
 		const thinkingConfig = {
 			type: "enabled",
@@ -373,12 +563,30 @@ function configureThinking(data) {
 		updatedData.additionalModelRequestFields.thinking = thinkingConfig;
 		delete updatedData.additionalModelRequestFields.thinkingBudget;
 	} else if (typeof thinking === "object" && thinking != null && thinking.type === "adaptive") {
-		if (updatedData.maxTokens == null && updatedData.maxOutputTokens != null) updatedData.maxTokens = updatedData.maxOutputTokens;
+		updatedData.maxTokens = resolveThinkingMaxTokens(updatedData);
 		delete updatedData.maxOutputTokens;
 		delete updatedData.additionalModelRequestFields.thinkingBudget;
 	}
 	return updatedData;
 }
+/** Top-level Converse request fields (issue #14029: `system` from a preset).
+*  The input parser's catch-all routes unknown keys into
+*  additionalModelRequestFields, and Bedrock rejects any that collide with a
+*  field the request already sends (`messages`/`modelId` always,
+*  `inferenceConfig` whenever maxTokens is set, `toolConfig` for agents). */
+const RESERVED_CONVERSE_FIELDS = [
+	"system",
+	"messages",
+	"modelId",
+	"toolConfig",
+	"inferenceConfig",
+	"guardrailConfig",
+	"promptVariables",
+	"requestMetadata",
+	"performanceConfig",
+	"additionalModelRequestFields",
+	"additionalModelResponseFieldPaths"
+];
 const bedrockOutputParser = (data) => {
 	const knownKeys = [
 		...Object.keys(require_data_service.tConversationSchema.shape),
@@ -397,7 +605,15 @@ const bedrockOutputParser = (data) => {
 	if (result.maxTokens !== void 0 && result.maxOutputTokens === void 0) result.maxOutputTokens = result.maxTokens;
 	else if (result.maxOutputTokens !== void 0 && result.maxTokens === void 0) result.maxTokens = result.maxOutputTokens;
 	result = configureThinking(result);
-	const amrf = result.additionalModelRequestFields;
+	let amrf = result.additionalModelRequestFields;
+	if (amrf && typeof amrf === "object") {
+		const reserved = RESERVED_CONVERSE_FIELDS.filter((key) => key in (amrf ?? {}));
+		if (reserved.length > 0) {
+			amrf = { ...amrf };
+			for (const key of reserved) delete amrf[key];
+			result.additionalModelRequestFields = amrf;
+		}
+	}
 	if (!amrf || Object.keys(amrf).length === 0) delete result.additionalModelRequestFields;
 	return result;
 };
@@ -414,6 +630,8 @@ let ContentTypes = /* @__PURE__ */ function(ContentTypes) {
 	ContentTypes["INPUT_AUDIO"] = "input_audio";
 	ContentTypes["AGENT_UPDATE"] = "agent_update";
 	ContentTypes["SUMMARY"] = "summary";
+	ContentTypes["ACTIVITY_LABEL"] = "activity_label";
+	ContentTypes["STEER"] = "steer";
 	ContentTypes["ERROR"] = "error";
 	return ContentTypes;
 }({});
@@ -438,10 +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). */
@@ -451,6 +673,45 @@ let UsageEvents = /* @__PURE__ */ function(UsageEvents) {
 	return UsageEvents;
 }({});
 /**
+* Human-in-the-loop event names. Streamed to live clients when a run pauses for
+* tool approval (or an ask-user question). Reconnecting clients instead read the
+* same record from `resumeState.pendingAction` on the sync event / status route.
+*/
+let ApprovalEvents = /* @__PURE__ */ function(ApprovalEvents) {
+	ApprovalEvents["ON_PENDING_ACTION"] = "on_pending_action";
+	return ApprovalEvents;
+}({});
+/**
+* Steering event names. `on_steer_applied` streams to live clients when a
+* queued steer message is injected at a tool-batch boundary; reconnecting
+* clients recover injected steers from `aggregatedContent` and still-queued
+* ones from `resumeState.pendingSteers`. Steers that never reach a boundary
+* ride the final/abort events as `pendingSteers`.
+*/
+let SteerEvents = /* @__PURE__ */ function(SteerEvents) {
+	SteerEvents["ON_STEER_APPLIED"] = "on_steer_applied";
+	/** Durable capability correction for queued steers after HITL handover. */
+	SteerEvents["ON_STEER_UPDATED"] = "on_steer_updated";
+	return SteerEvents;
+}({});
+/**
+* Activity-label event names. `on_activity_label` streams to live clients
+* when a tool-batch or parent-phase label part is claimed and again when the
+* fast-model label resolves; reconnecting clients recover applied labels
+* from `aggregatedContent` like any other content part.
+*/
+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;
+}({});
+/**
 * Full prompt token count for one completed model call — the EXACT context the
 * model saw, provider-aware: additive providers (Bedrock) report `input_tokens`
 * excluding cache, so cache reads/writes are added back; subset providers
@@ -657,19 +918,21 @@ const parseCompactConvo = ({ endpoint, endpointType, conversation, possibleValue
 	if (models && convo) convo.model = getFirstDefinedValue(models) ?? convo.model;
 	return convo;
 };
-function parseTextParts(contentParts, skipReasoning = false) {
+function parseTextParts(contentParts, skipReasoning = false, options) {
 	let result = "";
+	const append = (textValue) => {
+		if (result.length > 0 && textValue.length > 0 && result[result.length - 1] !== " " && textValue[0] !== " ") result += " ";
+		result += textValue;
+	};
 	for (const part of contentParts) {
 		if (!part?.type) continue;
-		if (part.type === "text") {
-			const textValue = (typeof part.text === "string" ? part.text : part.text?.value) || "";
-			if (result.length > 0 && textValue.length > 0 && result[result.length - 1] !== " " && textValue[0] !== " ") result += " ";
-			result += textValue;
-		} else if (part.type === "think" && !skipReasoning) {
-			const textValue = typeof part.think === "string" ? part.think : "";
-			if (result.length > 0 && textValue.length > 0 && result[result.length - 1] !== " " && textValue[0] !== " ") result += " ";
-			result += textValue;
-		}
+		if (part.type === "text") append((typeof part.text === "string" ? part.text : part.text?.value) || "");
+		else if (part.type === "steer" && options?.includeSteer === true)
+ /** Mid-run user speech: excluded by default so generic extraction (TTS
+		*  reading assistant output) never speaks the user's own words — the
+		*  full-record surfaces (search indexing, persisted abort text) opt in. */
+		append(typeof part.steer === "string" ? part.steer : "");
+		else if (part.type === "think" && !skipReasoning) append(typeof part.think === "string" ? part.think : "");
 	}
 	return result;
 }
@@ -723,6 +986,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.
 *
@@ -1014,15 +1285,132 @@ 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/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
+* parent, and a single-pass link would hoist such rows into phantom root
+* branches — folding the visible thread to one dangling branch until a
+* refetch restores creation order. Linking happens only after every message
+* is indexed, so array order never changes the tree shape.
+*/
 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 = [];
 	const childrenCount = {};
-	messages.forEach((message) => {
-		if (!message) return;
-		const parentId = message.parentMessageId ?? "";
+	for (const message of messages) {
+		if (!message) continue;
+		/** A self-parented row can never link under itself (it becomes a root),
+		*  so count it with the parentless group — charging its own id would
+		*  inflate the sibling indices of its real children past
+		*  `children.length`. */
+		const parentId = message.parentMessageId === message.messageId ? "" : message.parentMessageId ?? "";
 		childrenCount[parentId] = (childrenCount[parentId] || 0) + 1;
 		const extendedMessage = {
 			...message,
@@ -1032,13 +1420,102 @@ function buildTree({ messages, fileMap }) {
 		};
 		if (message.files && fileMap) extendedMessage.files = message.files.map((file) => fileMap[file.file_id ?? ""] ?? file);
 		messageMap[message.messageId] = extendedMessage;
-		const parentMessage = messageMap[parentId];
-		if (parentMessage) {
-			parentMessage.children.push(extendedMessage);
-			extendedMessage.depth = parentMessage.depth + 1;
-		} else rootMessages.push(extendedMessage);
-	});
-	return rootMessages;
+		orderedMessages.push(extendedMessage);
+	}
+	for (const extendedMessage of orderedMessages) {
+		const parentMessage = messageMap[extendedMessage.parentMessageId ?? ""];
+		if (parentMessage && parentMessage !== extendedMessage) parentMessage.children.push(extendedMessage);
+		else rootMessages.push(extendedMessage);
+	}
+	/** Depth comes from a roots-down walk (a child linked before its parent
+	*  can't inherit depth at link time). The `visited` set doubles as the
+	*  cycle guard: nodes on a corrupt parent cycle are unreachable from any
+	*  root, so they resurface as roots instead of disappearing. */
+	const visited = /* @__PURE__ */ new Set();
+	const assignDepths = (root) => {
+		visited.add(root);
+		const stack = [root];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			/** Every node has one parent, so this walk reaches each node once — an
+			*  already-visited child is a cycle back-edge. Sever it (not just skip
+			*  it) so consumers that recurse `children` terminate. */
+			if (node.children.some((child) => visited.has(child))) node.children = node.children.filter((child) => !visited.has(child));
+			for (const child of node.children) {
+				child.depth = node.depth + 1;
+				visited.add(child);
+				stack.push(child);
+			}
+		}
+	};
+	for (const root of rootMessages) assignDepths(root);
+	for (const extendedMessage of orderedMessages) if (!visited.has(extendedMessage)) {
+		rootMessages.push(extendedMessage);
+		assignDepths(extendedMessage);
+	}
+	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;
+}
+//#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
@@ -4211,6 +4688,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;
 }({});
 /**
@@ -4234,11 +4715,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.
@@ -4339,6 +4829,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),
@@ -4360,7 +4854,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
@@ -4441,6 +4936,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)
 			})
 		})
 	}),
@@ -4514,6 +5013,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	},
@@ -4569,6 +5072,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	}
@@ -4588,6 +5095,308 @@ 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() });
+//#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,
@@ -4620,6 +5429,171 @@ 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;
+//#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["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",
+	["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",
+	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/actions.ts
 function sha1(input) {
 	return crypto.default.createHash("sha1").update(input).digest("hex");
@@ -4946,6 +5920,27 @@ function extractDomainFromUrl(url$2) {
 		throw new Error(`Invalid URL format: ${url$2}`);
 	}
 }
+function getExplicitPort(value) {
+	const normalizedValue = value.trim();
+	const protocolSeparatorIndex = normalizedValue.indexOf("://");
+	const hasProtocol = protocolSeparatorIndex !== -1;
+	const authorityAndPath = hasProtocol ? normalizedValue.slice(protocolSeparatorIndex + 3) : normalizedValue;
+	let port;
+	try {
+		const parsedUrl = new url.URL(hasProtocol ? normalizedValue : `https://${normalizedValue}`);
+		port = parsedUrl.port;
+		if (!port && (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:")) port = new url.URL(`${parsedUrl.protocol === "http:" ? "https:" : "http:"}//${authorityAndPath}`).port;
+	} catch {
+		return null;
+	}
+	if (!port) return null;
+	const parsedPort = Number(port);
+	if (!Number.isInteger(parsedPort) || parsedPort < 1 || parsedPort > 65535) throw new Error(`Invalid port in domain: ${value}`);
+	return String(parsedPort);
+}
+function getDefaultActionPort(protocol) {
+	return protocol === "https:" ? "443" : "80";
+}
 /**
 * Validates client domain matches OpenAPI spec server URL domain (SSRF prevention).
 * @param clientProvidedDomain - Domain from client (with/without protocol)
@@ -4966,6 +5961,7 @@ function validateActionDomain(clientProvidedDomain, specServerUrl) {
 		/** Extract hostname from client domain if it's a full URL */
 		let clientHostname = clientProvidedDomain;
 		let clientHasProtocol = false;
+		const clientExplicitPort = getExplicitPort(clientProvidedDomain);
 		if (clientProvidedDomain.includes("://")) {
 			if (!clientProvidedDomain.startsWith("http://") && !clientProvidedDomain.startsWith("https://")) return {
 				isValid: false,
@@ -4977,7 +5973,7 @@ function validateActionDomain(clientProvidedDomain, specServerUrl) {
 			} catch {
 				clientHasProtocol = false;
 			}
-		}
+		} else if (clientExplicitPort !== null) clientHostname = new url.URL(`https://${clientProvidedDomain}`).hostname;
 		/** Normalize IPv6 addresses by removing brackets for comparison */
 		const normalizedClientHostname = clientHostname.replace(/^\[(.+)\]$/, "$1");
 		const normalizedSpecHostname = specHostname.replace(/^\[(.+)\]$/, "$1");
@@ -4990,14 +5986,23 @@ function validateActionDomain(clientProvidedDomain, specServerUrl) {
 			const hostname = isIP(normalizedClientHostname) === 6 && !clientHostname.startsWith("[") ? `[${normalizedClientHostname}]` : clientHostname;
 			normalizedClientDomain = `${specUrl.protocol}//${hostname}`;
 		} else normalizedClientDomain = `https://${clientHostname}`;
-		if (normalizedSpecDomain === normalizedClientDomain || !clientHasProtocol && isIPAddress && normalizedClientHostname === normalizedSpecHostname) return {
-			isValid: true,
+		if (!(normalizedSpecDomain === normalizedClientDomain || !clientHasProtocol && isIPAddress && normalizedClientHostname === normalizedSpecHostname)) return {
+			isValid: false,
+			message: `Domain mismatch: Client provided '${clientProvidedDomain}', but spec uses '${specHostname}'`,
 			normalizedSpecDomain,
 			normalizedClientDomain
 		};
+		if (clientExplicitPort !== null) {
+			const specEffectivePort = specUrl.port || getDefaultActionPort(specUrl.protocol);
+			if (clientExplicitPort !== specEffectivePort) return {
+				isValid: false,
+				message: `Port mismatch: Client provided '${clientProvidedDomain}', but spec uses effective port '${specEffectivePort}'`,
+				normalizedSpecDomain,
+				normalizedClientDomain
+			};
+		}
 		return {
-			isValid: false,
-			message: `Domain mismatch: Client provided '${clientProvidedDomain}', but spec uses '${specHostname}'`,
+			isValid: true,
 			normalizedSpecDomain,
 			normalizedClientDomain
 		};
@@ -5072,11 +6077,13 @@ function getUserTimezone() {
 	}
 }
 function createPayload(submission) {
-	const { isEdited, addedConvo, userMessage, isContinued, isTemporary, isRegenerate, conversation, editedContent, ephemeralAgent, endpointOption, manualSkills } = submission;
+	const { isEdited, addedConvo, userMessage, isContinued, isTemporary, isRegenerate, conversation, editedContent, ephemeralAgent, endpointOption, manualSkills, 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,
@@ -5090,7 +6097,10 @@ function createPayload(submission) {
 		isContinued: !!(isEdited && isContinued),
 		ephemeralAgent: require_data_service.isAssistantsEndpoint(endpoint) ? void 0 : ephemeralAgent,
 		manualSkills: require_data_service.isAssistantsEndpoint(endpoint) ? void 0 : manualSkills,
-		timezone: getUserTimezone()
+		timezone: getUserTimezone(),
+		clientRequestId,
+		recoverySteerId,
+		expectedPredecessorCreatedAt
 	};
 	return {
 		server,
@@ -5149,28 +6159,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) => {
@@ -5197,7 +6185,7 @@ const librechat = {
 		labelCode: true,
 		type: "number",
 		component: "input",
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		description: "com_endpoint_context_info",
 		descriptionCode: true,
@@ -5228,13 +6216,37 @@ 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",
 		labelCode: true,
 		description: "com_ui_file_token_limit_desc",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		type: "number",
 		component: "input",
@@ -5306,7 +6318,7 @@ const openAIParams = {
 		component: "input",
 		description: "com_endpoint_openai_max_tokens",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		optionType: "model",
 		columnSpan: 2
@@ -5327,7 +6339,8 @@ const openAIParams = {
 			"low",
 			"medium",
 			"high",
-			"xhigh"
+			"xhigh",
+			"max"
 		],
 		enumMappings: {
 			[""]: "com_ui_auto",
@@ -5336,7 +6349,8 @@ const openAIParams = {
 			["low"]: "com_ui_low",
 			["medium"]: "com_ui_medium",
 			["high"]: "com_ui_high",
-			["xhigh"]: "com_ui_xhigh"
+			["xhigh"]: "com_ui_xhigh",
+			["max"]: "com_ui_max"
 		},
 		optionType: "model",
 		columnSpan: 4
@@ -5391,6 +6405,52 @@ const openAIParams = {
 		optionType: "model",
 		columnSpan: 4
 	},
+	reasoning_mode: {
+		key: "reasoning_mode",
+		label: "com_endpoint_reasoning_mode",
+		labelCode: true,
+		description: "com_endpoint_openai_reasoning_mode",
+		descriptionCode: true,
+		type: "enum",
+		default: "",
+		component: "slider",
+		options: [
+			"",
+			"standard",
+			"pro"
+		],
+		enumMappings: {
+			[""]: "com_ui_unset",
+			["standard"]: "com_ui_standard",
+			["pro"]: "com_ui_pro"
+		},
+		optionType: "model",
+		columnSpan: 4
+	},
+	reasoning_context: {
+		key: "reasoning_context",
+		label: "com_endpoint_reasoning_context",
+		labelCode: true,
+		description: "com_endpoint_openai_reasoning_context",
+		descriptionCode: true,
+		type: "enum",
+		default: "",
+		component: "slider",
+		options: [
+			"",
+			"auto",
+			"current_turn",
+			"all_turns"
+		],
+		enumMappings: {
+			[""]: "com_ui_unset",
+			["auto"]: "com_ui_auto",
+			["current_turn"]: "com_ui_current_turn",
+			["all_turns"]: "com_ui_all_turns"
+		},
+		optionType: "model",
+		columnSpan: 4
+	},
 	verbosity: {
 		key: "verbosity",
 		label: "com_endpoint_verbosity",
@@ -5438,7 +6498,7 @@ const anthropic = {
 		component: "input",
 		description: "com_endpoint_anthropic_maxoutputtokens",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		range: {
 			min: require_data_service.anthropicSettings.maxOutputTokens.min,
@@ -5626,7 +6686,7 @@ const bedrock = {
 		component: "input",
 		description: "com_endpoint_anthropic_maxoutputtokens",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		optionType: "model",
 		columnSpan: 2
@@ -5758,6 +6818,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: {
@@ -5799,7 +6867,7 @@ const google = {
 		component: "input",
 		description: "com_endpoint_google_maxoutputtokens",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		default: require_data_service.googleSettings.maxOutputTokens.default,
 		range: {
@@ -5897,7 +6965,7 @@ const google = {
 const googleConfig = [
 	librechat.modelLabel,
 	librechat.promptPrefix,
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -5916,7 +6984,7 @@ const googleCol1 = [
 	librechat.promptPrefix
 ];
 const googleCol2 = [
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -5940,11 +7008,13 @@ const openAI = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.web_search,
 	openAIParams.reasoning_effort,
 	openAIParams.useResponsesApi,
 	openAIParams.reasoning_summary,
+	openAIParams.reasoning_mode,
+	openAIParams.reasoning_context,
 	openAIParams.verbosity,
 	openAIParams.disableStreaming,
 	librechat.fileTokenLimit
@@ -5968,9 +7038,11 @@ const openAICol2 = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.reasoning_effort,
 	openAIParams.reasoning_summary,
+	openAIParams.reasoning_mode,
+	openAIParams.reasoning_context,
 	openAIParams.verbosity,
 	openAIParams.useResponsesApi,
 	openAIParams.web_search,
@@ -6273,13 +7345,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
@@ -6306,12 +7436,42 @@ 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
+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;
+exports.ActivityLabelEvents = ActivityLabelEvents;
 exports.AgentCapabilities = require_data_service.AgentCapabilities;
 exports.AnnotationTypes = require_data_service.AnnotationTypes;
 exports.AnthropicEffort = require_data_service.AnthropicEffort;
+exports.ApprovalEvents = ApprovalEvents;
 exports.ArtifactModes = ArtifactModes;
 exports.AssistantStreamEvents = require_data_service.AssistantStreamEvents;
 exports.AuthKeys = require_data_service.AuthKeys;
@@ -6319,11 +7479,14 @@ exports.AuthType = require_data_service.AuthType;
 exports.AuthTypeEnum = require_data_service.AuthTypeEnum;
 exports.AuthorizationTypeEnum = require_data_service.AuthorizationTypeEnum;
 exports.BASE_ONLY_CONFIG_SECTIONS = require_data_service.BASE_ONLY_CONFIG_SECTIONS;
+exports.BASE_PRINCIPAL_CONFIG_SECTIONS = require_data_service.BASE_PRINCIPAL_CONFIG_SECTIONS;
 exports.BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA = BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA;
 exports.BEDROCK_OUTPUT_128K_BETA = BEDROCK_OUTPUT_128K_BETA;
 exports.BedrockProviders = require_data_service.BedrockProviders;
 exports.BedrockReasoningConfig = require_data_service.BedrockReasoningConfig;
 exports.CODE_ENV_KINDS = CODE_ENV_KINDS;
+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.CohereConstants = require_data_service.CohereConstants;
@@ -6338,15 +7501,22 @@ 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_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;
@@ -6355,31 +7525,55 @@ exports.InfiniteCollections = require_data_service.InfiniteCollections;
 exports.InvocationMode = InvocationMode;
 exports.KnownEndpoints = require_data_service.KnownEndpoints;
 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_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;
 exports.MutationKeys = require_data_service.MutationKeys;
 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;
 exports.ReasoningSummary = require_data_service.ReasoningSummary;
@@ -6387,11 +7581,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;
@@ -6399,6 +7595,8 @@ 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.SafeSearchTypes = require_data_service.SafeSearchTypes;
 exports.ScraperProviders = require_data_service.ScraperProviders;
@@ -6407,13 +7605,16 @@ 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;
 exports.StepStatus = require_data_service.StepStatus;
 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.TTSProviders = require_data_service.TTSProviders;
 exports.ThinkingDisplay = require_data_service.ThinkingDisplay;
 exports.ThinkingLevel = require_data_service.ThinkingLevel;
@@ -6431,8 +7632,15 @@ 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.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;
@@ -6463,6 +7671,7 @@ exports.balanceSchema = require_data_service.balanceSchema;
 exports.baseEndpointSchema = require_data_service.baseEndpointSchema;
 exports.bedrockDocumentExtensions = require_data_service.bedrockDocumentExtensions;
 exports.bedrockDocumentFormats = require_data_service.bedrockDocumentFormats;
+exports.bedrockDocumentMimeTypes = require_data_service.bedrockDocumentMimeTypes;
 exports.bedrockEndpointSchema = require_data_service.bedrockEndpointSchema;
 exports.bedrockGuardrailConfigSchema = require_data_service.bedrockGuardrailConfigSchema;
 exports.bedrockInputParser = bedrockInputParser;
@@ -6472,15 +7681,29 @@ exports.bedrockOutputParser = bedrockOutputParser;
 exports.bookmarkPermissionsSchema = bookmarkPermissionsSchema;
 exports.breadcrumb = breadcrumb;
 exports.buildLoginRedirectUrl = require_data_service.buildLoginRedirectUrl;
+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.cancelAgentQueuedTurnResponseSchema = cancelAgentQueuedTurnResponseSchema;
+exports.cancelAgentQueuedTurnSchema = cancelAgentQueuedTurnSchema;
+exports.capsEffortWhenThinkingDisabled = capsEffortWhenThinkingDisabled;
 exports.card = card;
 exports.carousel = carousel;
 exports.checkOpenAIStorage = require_data_service.checkOpenAIStorage;
 exports.checkbox = checkbox;
+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;
@@ -6492,9 +7715,13 @@ 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.createPayload = createPayload;
+exports.createSchedulePayloadSchema = createSchedulePayloadSchema;
 exports.createURL = createURL;
+exports.cronCadenceSchema = cronCadenceSchema;
 Object.defineProperty(exports, "dataService", {
 	enumerable: true,
 	get: function() {
@@ -6521,7 +7748,9 @@ exports.dropdownMenu = dropdownMenu;
 exports.eAnthropicEffortSchema = require_data_service.eAnthropicEffortSchema;
 exports.eImageDetailSchema = require_data_service.eImageDetailSchema;
 exports.eModelEndpointSchema = require_data_service.eModelEndpointSchema;
+exports.eReasoningContextSchema = require_data_service.eReasoningContextSchema;
 exports.eReasoningEffortSchema = require_data_service.eReasoningEffortSchema;
+exports.eReasoningModeSchema = require_data_service.eReasoningModeSchema;
 exports.eReasoningParameterFormatSchema = require_data_service.eReasoningParameterFormatSchema;
 exports.eReasoningResponseKeySchema = require_data_service.eReasoningResponseKeySchema;
 exports.eReasoningSummarySchema = require_data_service.eReasoningSummarySchema;
@@ -6533,6 +7762,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;
@@ -6543,32 +7775,48 @@ 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.findLastSeparatorIndex = findLastSeparatorIndex;
 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.getCodeEnvRefForProfile = getCodeEnvRefForProfile;
+exports.getCodeEnvRefs = getCodeEnvRefs;
 exports.getConfigDefaults = require_data_service.getConfigDefaults;
+exports.getConfiguredMimeAccept = require_data_service.getConfiguredMimeAccept;
 exports.getDefaultParamsEndpoint = require_data_service.getDefaultParamsEndpoint;
 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.getSchemaDefaults = require_data_service.getSchemaDefaults;
 exports.getSettingsKeys = require_data_service.getSettingsKeys;
 exports.getTagByKey = require_data_service.getTagByKey;
@@ -6578,7 +7826,11 @@ 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.hostImageIdSuffix = require_data_service.hostImageIdSuffix;
 exports.hostImageNamePrefix = require_data_service.hostImageNamePrefix;
 exports.hoverCard = hoverCard;
@@ -6595,8 +7847,11 @@ exports.inputTokensIncludesCache = require_data_service.inputTokensIncludesCache
 exports.interfaceSchema = require_data_service.interfaceSchema;
 exports.isActionTool = require_data_service.isActionTool;
 exports.isAgentsEndpoint = require_data_service.isAgentsEndpoint;
+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.isCronCadence = isCronCadence;
 exports.isDocumentSupportedProvider = require_data_service.isDocumentSupportedProvider;
 exports.isEphemeralAgentId = isEphemeralAgentId;
 exports.isImageVisionTool = require_data_service.isImageVisionTool;
@@ -6604,32 +7859,52 @@ exports.isMythosClassModel = require_data_service.isMythosClassModel;
 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.isSecureCodeEnvironmentControlURL = require_data_service.isSecureCodeEnvironmentControlURL;
 exports.isSensitiveEnvVar = require_data_service.isSensitiveEnvVar;
 exports.isSystemRoleName = isSystemRoleName;
+exports.isThinkingDisabled = isThinkingDisabled;
 exports.isUUID = require_data_service.isUUID;
+exports.isValidCronExpression = isValidCronExpression;
+exports.knownEndpointToProvider = knownEndpointToProvider;
 exports.label = label;
+exports.langfuseConfigSchema = require_data_service.langfuseConfigSchema;
 exports.librechat = librechat;
+exports.listAgentQueuedTurnsResponseSchema = listAgentQueuedTurnsResponseSchema;
+exports.listAgentQueuedTurnsSchema = listAgentQueuedTurnsSchema;
 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.mcpServersPermissionsSchema = mcpServersPermissionsSchema;
 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;
 exports.omitsThinkingByDefault = omitsThinkingByDefault;
@@ -6646,6 +7921,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;
@@ -6655,6 +7931,7 @@ 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;
@@ -6663,34 +7940,60 @@ exports.rateLimitSchema = require_data_service.rateLimitSchema;
 exports.reconcileContextUsage = reconcileContextUsage;
 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.resolveEndpointType = require_data_service.resolveEndpointType;
+exports.resolveModelCatalogKey = resolveModelCatalogKey;
+exports.resolveModelSpecEndpoint = require_data_service.resolveModelSpecEndpoint;
+exports.resolveProviderId = resolveProviderId;
 exports.resolveRef = resolveRef;
+exports.resolveStatefulCodeEnvironment = require_data_service.resolveStatefulCodeEnvironment;
 exports.resolveThinkingDisplay = resolveThinkingDisplay;
 exports.resourcePermissionsResponseSchema = require_data_service.resourcePermissionsResponseSchema;
+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.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;
 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;
 exports.slider = slider;
 exports.specialVariables = require_data_service.specialVariables;
 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.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;
@@ -6698,6 +8001,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;
@@ -6722,13 +8026,20 @@ exports.toast = toast;
 exports.toaster = toaster;
 exports.toggle = toggle;
 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.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;