librechat-data-provider 0.8.521 → 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-DOIF4BkW.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");
@@ -190,6 +191,17 @@ function supportsContext1m(model) {
 	return false;
 }
 /**
+* Checks whether a native Anthropic Claude model supports prompt caching.
+*
+* This uses the configured model ID directly. Resolving it through a token
+* map first can collapse a newly released Claude model to the generic
+* `claude-` fallback and incorrectly disable cache control.
+*/
+function supportsPromptCache(model) {
+	if (model.includes("claude-3-5-sonnet-latest") || model.includes("claude-3.5-sonnet-latest")) return false;
+	return /claude-3[-.]7/.test(model) || /claude-3[-.]5-(?:sonnet|haiku)/.test(model) || /claude-3-(?:sonnet|haiku|opus)?/.test(model) || /claude-(?:sonnet|opus|haiku)[-.]?(?:[4-9]|\d{2,})/.test(model) || /claude-(?:[4-9]|\d{2,})(?:[-.](?:sonnet|opus|haiku))?/.test(model) || require_data_service.isMythosClassModel(model);
+}
+/**
 * A Bedrock Claude model ID may be prefixed (`anthropic.claude-*`,
 * `us.anthropic.claude-*`, `global.anthropic.claude-*`) or bare (`claude-*`,
 * used when the LibreChat model ID maps to an application inference profile).
@@ -644,11 +656,14 @@ let StepEvents = /* @__PURE__ */ function(StepEvents) {
 	StepEvents["ON_REASONING_DELTA"] = "on_reasoning_delta";
 	StepEvents["ON_RUN_STEP_DELTA"] = "on_run_step_delta";
 	StepEvents["ON_RUN_STEP_COMPLETED"] = "on_run_step_completed";
+	/** Terminal signal for a run step: closed with a status and timestamps. */
+	StepEvents["ON_RUN_STEP_CLOSED"] = "on_run_step_closed";
 	StepEvents["ON_SUMMARIZE_START"] = "on_summarize_start";
 	StepEvents["ON_SUMMARIZE_DELTA"] = "on_summarize_delta";
 	StepEvents["ON_SUMMARIZE_COMPLETE"] = "on_summarize_complete";
 	StepEvents["ON_SUBAGENT_UPDATE"] = "on_subagent_update";
 	StepEvents["ON_SANDBOX_STARTING"] = "on_sandbox_starting";
+	StepEvents["ON_PTC_TOOL_CALL"] = "on_ptc_tool_call";
 	return StepEvents;
 }({});
 /** Token-tracking event names streamed to the client (separate from StepEvents dispatch). */
@@ -689,6 +704,13 @@ 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`
@@ -964,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.
 *
@@ -1255,7 +1285,106 @@ 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
@@ -1266,6 +1395,11 @@ function mapGroupToAzureConfig({ groupName, groupMap }) {
 */
 function buildTree({ messages, fileMap }) {
 	if (messages === null) return null;
+	const cached = treeCache.get(messages);
+	if (cached) {
+		if (fileMap == null && cached.bare) return cached.bare;
+		if (fileMap != null && cached.fileMap === fileMap && cached.hydrated) return cached.hydrated;
+	}
 	const messageMap = {};
 	const orderedMessages = [];
 	const rootMessages = [];
@@ -1319,7 +1453,69 @@ function buildTree({ messages, fileMap }) {
 		rootMessages.push(extendedMessage);
 		assignDepths(extendedMessage);
 	}
-	return rootMessages;
+	const tree = rootMessages;
+	const entry = cached ?? {};
+	if (fileMap == null) entry.bare = tree;
+	else {
+		entry.fileMap = fileMap;
+		entry.hydrated = tree;
+	}
+	if (!cached) treeCache.set(messages, entry);
+	return tree;
+}
+//#endregion
+//#region src/runSteps.ts
+/**
+* Below this, a duration is noise rather than information: sub-second tool
+* calls are the common case, and labelling every one of them `· 0.3s` adds a
+* moving number to the end of most cards without telling the reader anything
+* they could act on. Callers use {@link isReportableRunStepDuration} rather
+* than comparing against this directly.
+*/
+const MIN_REPORTABLE_RUN_STEP_DURATION_MS = 1e3;
+/**
+* Wall-clock duration of a run step, derived from the terminal
+* `on_run_step_closed` event.
+*
+* Returns `undefined` rather than a fallback whenever the value would be a
+* guess, because a wrong duration is worse than an absent one — an absent one
+* renders nothing, a wrong one is indistinguishable from a real measurement:
+*
+* - `created_at` is optional on the event; emitters that do not know when the
+*   step opened cannot have their duration inferred from anything else.
+* - A negative result means the two timestamps came from clocks that disagree.
+*   That is not hypothetical: since `@librechat/agents` v3.6.0 a step can be
+*   opened in one process and closed in another after a checkpoint resume, so
+*   the two stamps can legitimately originate on different machines.
+* - Non-finite input is treated as absent instead of propagating `NaN` into
+*   rendering.
+*
+* Known limits, accepted rather than guessed at: only the negative direction
+* of clock skew is detectable from a single stamp pair — positive skew
+* inflates the result and cannot be distinguished from a genuinely long
+* step. And the value is wall-clock elapsed between open and close, so a
+* step held open across a suspension (a checkpoint resume, a HITL approval
+* wait) includes that held-open time. Both are properties of the only data
+* available, not derivation bugs.
+*/
+function getRunStepDurationMs(closed) {
+	const { created_at: createdAt, closed_at: closedAt } = closed;
+	if (typeof createdAt !== "number" || typeof closedAt !== "number") return;
+	if (!Number.isFinite(createdAt) || !Number.isFinite(closedAt)) return;
+	const durationMs = closedAt - createdAt;
+	return durationMs >= 0 ? durationMs : void 0;
+}
+/**
+* Whether a derived duration is worth showing to the reader.
+*
+* This is a presentation judgment, so it belongs at render time only. The
+* stamp sites persist the raw {@link getRunStepDurationMs} value instead of
+* pre-filtering through this — thresholding at write time would bake a
+* display rule into stored data, making "fast" indistinguishable from "not
+* derivable" and unrecoverable if the rule ever changes.
+*/
+function isReportableRunStepDuration(durationMs) {
+	return typeof durationMs === "number" && durationMs >= 1e3;
 }
 //#endregion
 //#region src/artifacts.ts
@@ -4492,6 +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;
 }({});
 /**
@@ -4515,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.
@@ -4620,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),
@@ -4641,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
@@ -4722,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)
 			})
 		})
 	}),
@@ -4795,6 +5013,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	},
@@ -4850,6 +5072,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	}
@@ -4869,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,
@@ -4901,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");
@@ -5388,7 +6081,9 @@ function createPayload(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,
@@ -5464,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) => {
@@ -5543,6 +6216,30 @@ const librechat = {
 		placeholderCode: true,
 		optionType: "model"
 	},
+	/** Controls how LibreChat encodes image content blocks, not a provider request
+	* parameter — so it belongs to this group and is stripped from model options. */
+	imageDetail: {
+		key: "imageDetail",
+		label: "com_endpoint_plug_image_detail",
+		labelCode: true,
+		description: "com_endpoint_openai_detail",
+		descriptionCode: true,
+		type: "enum",
+		default: "auto",
+		component: "slider",
+		options: [
+			"low",
+			"auto",
+			"high"
+		],
+		enumMappings: {
+			["low"]: "com_ui_low",
+			["auto"]: "com_ui_auto",
+			["high"]: "com_ui_high"
+		},
+		optionType: "conversation",
+		columnSpan: 2
+	},
 	fileTokenLimit: {
 		key: "fileTokenLimit",
 		label: "com_ui_file_token_limit",
@@ -6121,6 +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: {
@@ -6260,7 +6965,7 @@ const google = {
 const googleConfig = [
 	librechat.modelLabel,
 	librechat.promptPrefix,
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -6279,7 +6984,7 @@ const googleCol1 = [
 	librechat.promptPrefix
 ];
 const googleCol2 = [
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -6303,7 +7008,7 @@ const openAI = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.web_search,
 	openAIParams.reasoning_effort,
 	openAIParams.useResponsesApi,
@@ -6333,7 +7038,7 @@ const openAICol2 = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.reasoning_effort,
 	openAIParams.reasoning_summary,
 	openAIParams.reasoning_mode,
@@ -6640,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
@@ -6673,7 +7436,34 @@ 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;
@@ -6695,6 +7485,8 @@ 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;
@@ -6709,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;
@@ -6726,14 +7525,31 @@ 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;
@@ -6742,17 +7558,21 @@ exports.OCRStrategy = require_data_service.OCRStrategy;
 exports.OptionTypes = require_data_service.OptionTypes;
 exports.PERMISSION_SUB_KEYS = PERMISSION_SUB_KEYS;
 exports.PERMISSION_TYPE_INTERFACE_FIELDS = PERMISSION_TYPE_INTERFACE_FIELDS;
+exports.PROMPT_FILTER_FIELDS = require_data_service.PROMPT_FILTER_FIELDS;
 exports.PermissionBits = require_data_service.PermissionBits;
 exports.PermissionTypes = PermissionTypes;
 exports.Permissions = Permissions;
 exports.PrincipalModel = require_data_service.PrincipalModel;
 exports.PrincipalType = require_data_service.PrincipalType;
+exports.ProviderId = ProviderId;
 exports.Providers = require_data_service.Providers;
 exports.QueryKeys = require_data_service.QueryKeys;
 exports.REFILL_INTERVAL_UNITS = require_data_service.REFILL_INTERVAL_UNITS;
+exports.RUNTIME_CONFIG_INTERFACE_FIELDS = RUNTIME_CONFIG_INTERFACE_FIELDS;
 exports.RateLimitPrefix = require_data_service.RateLimitPrefix;
 exports.ReasoningContext = require_data_service.ReasoningContext;
 exports.ReasoningEffort = require_data_service.ReasoningEffort;
+exports.ReasoningLabelEvents = ReasoningLabelEvents;
 exports.ReasoningMode = require_data_service.ReasoningMode;
 exports.ReasoningParameterFormat = require_data_service.ReasoningParameterFormat;
 exports.ReasoningResponseKey = require_data_service.ReasoningResponseKey;
@@ -6761,11 +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;
@@ -6773,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;
@@ -6781,6 +7605,7 @@ exports.SearchProviders = require_data_service.SearchProviders;
 exports.SettingTypes = require_data_service.SettingTypes;
 exports.SettingsTabValues = require_data_service.SettingsTabValues;
 exports.SettingsViews = require_data_service.SettingsViews;
+exports.SkillsScope = require_data_service.SkillsScope;
 exports.StdioOptionsSchema = require_data_service.StdioOptionsSchema;
 exports.SteerEvents = SteerEvents;
 exports.StepEvents = StepEvents;
@@ -6789,6 +7614,7 @@ 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;
@@ -6806,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;
@@ -6852,7 +7685,11 @@ 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;
@@ -6862,7 +7699,11 @@ exports.checkpointerSchema = require_data_service.checkpointerSchema;
 exports.checkpointerTypeSchema = require_data_service.checkpointerTypeSchema;
 exports.clampEffortForDisabledThinking = clampEffortForDisabledThinking;
 exports.clampOutputConfigEffort = clampOutputConfigEffort;
+exports.clampSettingRange = require_data_service.clampSettingRange;
 exports.cloudfrontConfigSchema = require_data_service.cloudfrontConfigSchema;
+exports.codeEnvironmentPermissionDecisionSchema = require_data_service.codeEnvironmentPermissionDecisionSchema;
+exports.codeEnvironmentUserConfigSchema = require_data_service.codeEnvironmentUserConfigSchema;
+exports.codeEnvironmentUserSettingsSchema = require_data_service.codeEnvironmentUserSettingsSchema;
 exports.codeInterpreterMimeTypes = require_data_service.codeInterpreterMimeTypes;
 exports.codeInterpreterMimeTypesList = require_data_service.codeInterpreterMimeTypesList;
 exports.codeTypeMapping = require_data_service.codeTypeMapping;
@@ -6874,9 +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() {
@@ -6917,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;
@@ -6927,33 +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;
@@ -6963,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;
@@ -6984,6 +7851,7 @@ 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;
@@ -6991,35 +7859,51 @@ 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;
@@ -7037,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;
@@ -7046,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;
@@ -7054,12 +7940,19 @@ 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;
@@ -7068,10 +7961,16 @@ 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;
@@ -7079,6 +7978,7 @@ exports.shadcnComponents = shadcnComponents;
 exports.sharedFileDownload = require_data_service.sharedFileDownload;
 exports.sharedLinksPermissionsSchema = sharedLinksPermissionsSchema;
 exports.skeleton = skeleton;
+exports.skillFilterFieldSchema = require_data_service.skillFilterFieldSchema;
 exports.skillPermissionsSchema = skillPermissionsSchema;
 exports.skillSyncConfigSchema = require_data_service.skillSyncConfigSchema;
 exports.skillSyncGitHubSourceSchema = require_data_service.skillSyncGitHubSourceSchema;
@@ -7088,6 +7988,12 @@ 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;
@@ -7095,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;
@@ -7122,13 +8029,17 @@ 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;