librechat-data-provider 0.8.521 → 0.8.523

package/dist/{data-service-DOIF4BkW.js → data-service-CTX0tVO5.js}

@@ -30,6 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let zod = require("zod");
+let re2js = require("re2js");
 let axios = require("axios");
 axios = __toESM(axios);
 //#region src/utils.ts
@@ -97,6 +98,304 @@ function normalizeEndpointName(name = "") {
 	return name.toLowerCase() === "ollama" ? "ollama" : name;
 }
 //#endregion
+//#region src/filters.ts
+const FILTER_PII_STARTER_PATTERNS = [
+	"sk_prefix",
+	"bearer_header",
+	"api_key_header"
+];
+const MAX_PII_PATTERNS_PER_SOURCE = 256;
+const MAX_PII_PATTERN_LENGTH = 512;
+const MAX_PII_PATTERN_ID_LENGTH = 256;
+const MAX_PII_PATTERN_LABEL_LENGTH = 512;
+const MAX_PII_CUSTOM_REGEX_CHARACTERS = 8192;
+const MAX_PII_CUSTOM_REGEX_INSTRUCTIONS = 8192;
+const MAX_PII_CUSTOM_PATTERNS_TOTAL = 256;
+const MAX_PII_REGEX_SIZE_CACHE_ENTRIES = 512;
+const PII_REGEX_PROGRAM_SIZE_CACHE = /* @__PURE__ */ new Map();
+function getPiiRegexProgramSize(pattern) {
+	if (PII_REGEX_PROGRAM_SIZE_CACHE.has(pattern)) return PII_REGEX_PROGRAM_SIZE_CACHE.get(pattern) ?? null;
+	let programSize = null;
+	let compiled;
+	try {
+		compiled = re2js.RE2JS.compile(pattern);
+		const candidate = compiled.programSize();
+		if (Number.isSafeInteger(candidate) && candidate > 0) programSize = candidate;
+	} catch {
+		programSize = null;
+	} finally {
+		compiled?.reset();
+	}
+	if (PII_REGEX_PROGRAM_SIZE_CACHE.size >= MAX_PII_REGEX_SIZE_CACHE_ENTRIES) PII_REGEX_PROGRAM_SIZE_CACHE.clear();
+	PII_REGEX_PROGRAM_SIZE_CACHE.set(pattern, programSize);
+	return programSize;
+}
+const MESSAGE_FILTER_FIELDS = [
+	"name",
+	"text",
+	"summary",
+	"quote",
+	"answer",
+	"decision_response",
+	"decision_reason",
+	"content_part",
+	"attachment_reference",
+	"assembled_context"
+];
+const HITL_MESSAGE_FILTER_FIELDS = [
+	"answer",
+	"decision_response",
+	"decision_reason"
+];
+const REQUEST_ONLY_MESSAGE_FILTER_FIELDS = new Set(HITL_MESSAGE_FILTER_FIELDS);
+/** Message fields structurally recoverable without exact semantic provenance. */
+const STORED_MESSAGE_FILTER_FIELDS = MESSAGE_FILTER_FIELDS.filter((field) => !REQUEST_ONLY_MESSAGE_FILTER_FIELDS.has(field));
+const PROMPT_FILTER_FIELDS = [
+	"name",
+	"description",
+	"oneliner",
+	"category",
+	"command",
+	"text",
+	"preset_text",
+	"system",
+	"context",
+	"instructions",
+	"additional_instructions",
+	"greeting",
+	"example_input",
+	"example_output"
+];
+const AGENT_INSTRUCTION_FILTER_FIELDS = [
+	"name",
+	"category",
+	"description",
+	"instructions",
+	"additional_instructions",
+	"edge_description",
+	"edge_prompt",
+	"edge_prompt_key",
+	"artifacts",
+	"support_contact_name",
+	"support_contact_email"
+];
+const CONVERSATION_STARTER_FILTER_FIELDS = ["text"];
+const CONVERSATION_TITLE_FILTER_FIELDS = ["title"];
+const FEEDBACK_FILTER_FIELDS = ["text"];
+const SKILL_FILTER_FIELDS = [
+	"name",
+	"display_title",
+	"description",
+	"category",
+	"frontmatter",
+	"instructions",
+	"imported_text",
+	"file_name",
+	"file_text"
+];
+const MEMORY_FILTER_FIELDS = [
+	"key",
+	"value",
+	"summary"
+];
+const FILE_FILTER_FIELDS = [
+	"name",
+	"content",
+	"extracted_text",
+	"transcript",
+	"uri"
+];
+const TOOL_ARGUMENT_FILTER_FIELDS = [
+	"name",
+	"arguments",
+	"output"
+];
+const MODEL_PARAMETER_FILTER_FIELDS = [
+	"stop",
+	"request_fields",
+	"response_format",
+	"metadata"
+];
+const ACTION_METADATA_FILTER_FIELDS = [
+	"raw_spec",
+	"domain",
+	"privacy_policy_url",
+	"authorization_type",
+	"custom_auth_header",
+	"authorization_content_type",
+	"authorization_url",
+	"client_url",
+	"scope",
+	"token_exchange_method",
+	"api_key",
+	"oauth_client_id",
+	"oauth_client_secret"
+];
+const messageFilterFieldSchema = zod.z.enum(MESSAGE_FILTER_FIELDS);
+const promptFilterFieldSchema = zod.z.enum(PROMPT_FILTER_FIELDS);
+const agentInstructionFilterFieldSchema = zod.z.enum(AGENT_INSTRUCTION_FILTER_FIELDS);
+const conversationStarterFilterFieldSchema = zod.z.enum(CONVERSATION_STARTER_FILTER_FIELDS);
+const conversationTitleFilterFieldSchema = zod.z.enum(CONVERSATION_TITLE_FILTER_FIELDS);
+const feedbackFilterFieldSchema = zod.z.enum(FEEDBACK_FILTER_FIELDS);
+const skillFilterFieldSchema = zod.z.enum(SKILL_FILTER_FIELDS);
+const memoryFilterFieldSchema = zod.z.enum(MEMORY_FILTER_FIELDS);
+const fileFilterFieldSchema = zod.z.enum(FILE_FILTER_FIELDS);
+const toolArgumentFilterFieldSchema = zod.z.enum(TOOL_ARGUMENT_FILTER_FIELDS);
+const modelParameterFilterFieldSchema = zod.z.enum(MODEL_PARAMETER_FILTER_FIELDS);
+const filterPiiStarterPatternSchema = zod.z.enum(FILTER_PII_STARTER_PATTERNS);
+const filterPiiActionSchema = zod.z.enum(["block", "audit"]);
+const actionMetadataFilterFieldSchema = zod.z.enum(ACTION_METADATA_FILTER_FIELDS);
+const unattributedAssistantContentSchema = zod.z.enum(["model_output", "inspect"]);
+const userSubmittedMessageFieldPathSchema = zod.z.object({
+	path: zod.z.string().startsWith("/").max(2048),
+	field: zod.z.enum(HITL_MESSAGE_FILTER_FIELDS)
+}).strict();
+const UNINSPECTABLE_FILE_FIELDS = new Set([
+	"content",
+	"extracted_text",
+	"transcript"
+]);
+/**
+* An omitted starter selection enables the built-in catalog. An explicit
+* empty selection disables it, so a source is active only when custom rules
+* remain. This mirrors the documented filter semantics without compiling
+* regular expressions.
+*/
+function hasActivePiiPatterns(config) {
+	return config != null && (config.starterPatterns == null || config.starterPatterns.length > 0 || (config.customPatterns?.length ?? 0) > 0);
+}
+/** Returns whether an active PII rule can inspect at least one candidate field. */
+function hasActivePiiFields(config, candidates) {
+	return hasActivePiiPatterns(config) && (config?.fields == null || candidates.some((field) => config.fields?.includes(field)));
+}
+/**
+* Returns whether a parsed source-aware config can enforce any rule. An
+* explicit fail-close file policy remains active even without text patterns.
+*/
+function hasActiveFiltersConfig(filters) {
+	if (filters == null) return false;
+	if (filters.messages?.unattributedAssistantContent === "inspect") return true;
+	if ([
+		filters.messages?.pii,
+		filters.prompts?.pii,
+		filters.agentInstructions?.pii,
+		filters.conversationStarters?.pii,
+		filters.conversationTitles?.pii,
+		filters.feedback?.pii,
+		filters.skills?.pii,
+		filters.memories?.pii,
+		filters.files?.pii,
+		filters.toolArguments?.pii,
+		filters.modelParameters?.pii,
+		filters.actionMetadata?.pii
+	].some(hasActivePiiPatterns)) return true;
+	const filePii = filters.files?.pii;
+	return filePii?.uninspectable === "block" && (filePii.fields == null || filePii.fields.some((field) => UNINSPECTABLE_FILE_FIELDS.has(field)));
+}
+const filterPiiRegexSchema = zod.z.string().min(1).max(512).refine((value) => getPiiRegexProgramSize(value) != null, { message: "Regex must use supported linear-time syntax" });
+const filterPiiCustomPatternSchema = zod.z.object({
+	id: zod.z.string().min(1).max(256),
+	label: zod.z.string().min(1).max(512),
+	regex: filterPiiRegexSchema
+}).strict();
+function createPiiFilterSchema(fieldSchema) {
+	return zod.z.object({
+		action: filterPiiActionSchema.optional(),
+		fields: zod.z.array(fieldSchema).min(1).max(256).optional(),
+		starterPatterns: zod.z.array(filterPiiStarterPatternSchema).max(256).optional(),
+		customPatterns: zod.z.array(filterPiiCustomPatternSchema).max(256).optional()
+	}).strict();
+}
+function createSourceFilterSchema(fieldSchema) {
+	return zod.z.object({ pii: createPiiFilterSchema(fieldSchema).optional() }).strict();
+}
+const messageSourceFilterSchema = zod.z.object({
+	pii: createPiiFilterSchema(messageFilterFieldSchema).optional(),
+	unattributedAssistantContent: unattributedAssistantContentSchema.optional()
+}).strict();
+const fileSourceFilterSchema = zod.z.object({ pii: createPiiFilterSchema(fileFilterFieldSchema).extend({ uninspectable: zod.z.enum(["allow", "block"]).optional() }).optional() }).strict();
+const filtersConfigSchema = zod.z.object({
+	messages: messageSourceFilterSchema.optional(),
+	prompts: createSourceFilterSchema(promptFilterFieldSchema).optional(),
+	agentInstructions: createSourceFilterSchema(agentInstructionFilterFieldSchema).optional(),
+	conversationStarters: createSourceFilterSchema(conversationStarterFilterFieldSchema).optional(),
+	conversationTitles: createSourceFilterSchema(conversationTitleFilterFieldSchema).optional(),
+	feedback: createSourceFilterSchema(feedbackFilterFieldSchema).optional(),
+	skills: createSourceFilterSchema(skillFilterFieldSchema).optional(),
+	memories: createSourceFilterSchema(memoryFilterFieldSchema).optional(),
+	files: fileSourceFilterSchema.optional(),
+	toolArguments: createSourceFilterSchema(toolArgumentFilterFieldSchema).optional(),
+	modelParameters: createSourceFilterSchema(modelParameterFilterFieldSchema).optional(),
+	actionMetadata: createSourceFilterSchema(actionMetadataFilterFieldSchema).optional()
+}).strict().superRefine((filters, context) => {
+	let customPatterns = 0;
+	let regexCharacters = 0;
+	let regexInstructions = 0;
+	for (const source of Object.values(filters)) for (const pattern of source?.pii?.customPatterns ?? []) {
+		customPatterns++;
+		regexCharacters += pattern.regex.length;
+		regexInstructions += getPiiRegexProgramSize(pattern.regex) ?? 0;
+	}
+	if (customPatterns > 256) context.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		message: `At most 256 custom PII patterns may be configured in total`
+	});
+	if (regexCharacters > 8192) context.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		message: `Custom PII regexes may contain at most ${MAX_PII_CUSTOM_REGEX_CHARACTERS} characters in total`
+	});
+	if (regexInstructions > 8192) context.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		message: `Custom PII regexes may compile to at most ${MAX_PII_CUSTOM_REGEX_INSTRUCTIONS} instructions in total`
+	});
+});
+//#endregion
+//#region src/code/workspace.ts
+const CODE_WORKSPACE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+/** Protocol-v1 ceiling enforced by the worker and Code API. */
+const CODE_WORKSPACE_MAX_COUNT = 32;
+/** API/client protocol for immutable conversation-owned environment decisions. */
+const CODE_ENVIRONMENT_DECISION_VERSION = 1;
+const CODE_WORKSPACE_OPERATIONS = [
+	"read_file",
+	"search_text",
+	"list_files",
+	"write_file",
+	"preview_edit",
+	"edit_file",
+	"execute_command"
+];
+const CODE_WORKSPACE_SELECTION_ERROR_REASONS = [
+	"required",
+	"invalid",
+	"worker_unavailable",
+	"unsupported",
+	"missing",
+	"locked"
+];
+const CODE_ENVIRONMENT_MODES = ["attached", "without_attached"];
+function isCodeEnvironmentMode(value) {
+	return CODE_ENVIRONMENT_MODES.some((mode) => mode === value);
+}
+function isCodeWorkspaceSelectionErrorReason(value) {
+	return CODE_WORKSPACE_SELECTION_ERROR_REASONS.some((reason) => reason === value);
+}
+function isCodeWorkspaceSelection(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	const selection = value;
+	return Object.keys(selection).every((key) => key === "environmentId" || key === "workspaceId") && typeof selection.environmentId === "string" && CODE_WORKSPACE_ID_PATTERN.test(selection.environmentId) && typeof selection.workspaceId === "string" && CODE_WORKSPACE_ID_PATTERN.test(selection.workspaceId);
+}
+/** One exact workspace per attached environment used by a conversation. */
+function isCodeWorkspaceSelections(value) {
+	if (!Array.isArray(value)) return false;
+	const environmentIds = /* @__PURE__ */ new Set();
+	return value.every((selection) => {
+		if (!isCodeWorkspaceSelection(selection) || environmentIds.has(selection.environmentId)) return false;
+		environmentIds.add(selection.environmentId);
+		return true;
+	});
+}
+//#endregion
 //#region src/feedback.ts
 const FEEDBACK_RATINGS = ["thumbsUp", "thumbsDown"];
 const FEEDBACK_REASON_KEYS = [
@@ -206,6 +505,82 @@ function getTagByKey(key) {
 	return FEEDBACK_TAGS.find((tag) => tag.key === key);
 }
 //#endregion
+//#region src/code/approval.ts
+const CODE_APPROVAL_MODES = [
+	"ask",
+	"acceptEdits",
+	"fullAccess"
+];
+const MODE_PERMISSIONS = {
+	ask: {
+		fileWrite: "ask",
+		commandExecution: "ask"
+	},
+	acceptEdits: {
+		fileWrite: "allow",
+		commandExecution: "ask"
+	},
+	fullAccess: {
+		fileWrite: "allow",
+		commandExecution: "allow"
+	}
+};
+/** Omitted deployment configuration never grants unattended execution. */
+function getAllowedCodeApprovalModes({ enabled, allowedModes, configSchema, settings, environment }) {
+	if (enabled === false) return [];
+	const permitted = new Set(allowedModes ?? ["ask"]);
+	return CODE_APPROVAL_MODES.filter((mode) => {
+		if (!permitted.has(mode)) return false;
+		if (environment === "managed") return true;
+		for (const category of ["fileWrite", "commandExecution"]) {
+			if (MODE_PERMISSIONS[mode][category] !== "allow") continue;
+			const field = configSchema?.permissions?.[category];
+			const configured = settings?.permissions?.[category];
+			if ((configured != null && field?.allowed.includes(configured) === true ? configured : field?.default ?? "ask") === "deny" || field?.allowed.includes("allow") !== true) return false;
+		}
+		return true;
+	});
+}
+var CodeApprovalModeError = class extends Error {
+	constructor() {
+		super("The selected code approval mode is not permitted by the current policy.");
+		this.code = "CODE_APPROVAL_MODE_NOT_ALLOWED";
+		this.name = "CodeApprovalModeError";
+	}
+};
+/** Validate untrusted request state again at admission, including after policy changes. */
+function resolveCodeApprovalMode(requested, constraints) {
+	if (requested == null) return void 0;
+	const selected = getAllowedCodeApprovalModes(constraints).find((mode) => mode === requested);
+	if (selected == null) throw new CodeApprovalModeError();
+	return selected;
+}
+/** Apply a turn preference without modifying machine settings or overriding an existing deny. */
+function resolveCodePermissionDecision({ mode, category, decision }) {
+	if (mode == null || decision === "deny") return decision;
+	if (MODE_PERMISSIONS[mode] == null) throw new CodeApprovalModeError();
+	return MODE_PERMISSIONS[mode][category];
+}
+//#endregion
+//#region src/stateful-code.ts
+const STATEFUL_CODE_ENVIRONMENTS = [
+	"user",
+	"agent-user",
+	"conversation"
+];
+/** Resolve a deployment allowlist in stable UI order. An omitted value preserves
+* the backward-compatible behavior where every environment is available. */
+function resolveAllowedStatefulCodeEnvironments(configured) {
+	if (configured == null) return [...STATEFUL_CODE_ENVIRONMENTS];
+	const configuredSet = new Set(configured);
+	return STATEFUL_CODE_ENVIRONMENTS.filter((environment) => configuredSet.has(environment));
+}
+/** Keep an allowed preference, otherwise select the first deployment-allowed scope. */
+function resolveStatefulCodeEnvironment(preferred, configured) {
+	const allowed = resolveAllowedStatefulCodeEnvironments(configured);
+	return preferred != null && allowed.includes(preferred) ? preferred : allowed[0];
+}
+//#endregion
 //#region src/types/assistants.ts
 let Tools = /* @__PURE__ */ function(Tools) {
 	Tools["execute_code"] = "execute_code";
@@ -230,6 +605,10 @@ let EToolResources = /* @__PURE__ */ function(EToolResources) {
 	EToolResources["ocr"] = "ocr";
 	return EToolResources;
 }({});
+const agentGitIdentitySchema = zod.z.object({
+	name: zod.z.string().trim().min(1).max(128).refine((value) => !/[\0\r\n]/.test(value)),
+	email: zod.z.string().trim().email().max(254).refine((value) => !/[\0\r\n]/.test(value))
+}).optional();
 let AnnotationTypes = /* @__PURE__ */ function(AnnotationTypes) {
 	AnnotationTypes["FILE_CITATION"] = "file_citation";
 	AnnotationTypes["FILE_PATH"] = "file_path";
@@ -421,7 +800,35 @@ const inputTokensIncludesCache = (provider) => {
 	return cacheSubsetProviders.has(provider ?? "");
 };
 const isDocumentSupportedProvider = (provider) => {
-	return documentSupportedProviders.has(provider ?? "");
+	const normalized = provider?.toLowerCase() ?? "";
+	return Array.from(documentSupportedProviders).some((candidate) => candidate.toLowerCase() === normalized);
+};
+/**
+* Endpoints whose encoders actually build native audio/video payloads. Narrower than
+* `documentSupportedProviders`: a provider can accept PDFs and still emit nothing for
+* media, in which case the upload has to fall back to text/STT.
+*/
+const mediaSupportedProviders = new Set([
+	"google",
+	"vertexai",
+	"openrouter"
+]);
+const isMediaSupportedProvider = (provider) => {
+	return mediaSupportedProviders.has(provider?.toLowerCase() ?? "");
+};
+/**
+* Built-in endpoint and provider identifiers. A name outside this set is a custom
+* endpoint whose real provider is resolved at request time, so its capabilities
+* cannot be judged from the name alone.
+*/
+const knownProviderIdentifiers = new Set([
+	...Object.values(EModelEndpoint),
+	...Object.values(Providers),
+	...Object.values(EModelEndpoint).map((provider) => provider.toLowerCase()),
+	...Object.values(Providers).map((provider) => provider.toLowerCase())
+]);
+const isKnownProviderIdentifier = (provider) => {
+	return knownProviderIdentifiers.has(provider?.toLowerCase() ?? "");
 };
 const paramEndpoints = new Set([
 	"agents",
@@ -622,6 +1029,9 @@ const defaultAgentFormValues = {
 	["file_search"]: false,
 	["web_search"]: false,
 	["memory"]: false,
+	stateful_code_environment: "user",
+	code_environment_id: void 0,
+	code_workspace_id: void 0,
 	category: "general",
 	support_contact: {
 		name: "",
@@ -633,6 +1043,10 @@ const defaultAgentFormValues = {
 	/** Master toggle for skill use on this agent. `true` activates skills
 	*  (full catalog unless `skills` narrows it). Anything else = inactive. */
 	skills_enabled: void 0,
+	/** Enables runtime skill creation without exposing an existing skill catalog. */
+	skill_authoring_enabled: void 0,
+	/** Explicit catalog scope. Missing preserves the legacy enabled + empty = all behavior. */
+	skills_scope: void 0,
 	/** `undefined` = feature disabled by default (no subagent tool injected). */
 	subagents: void 0,
 	/** Memory partition: 'agent' isolates memories per (user, agent); default shared pool */
@@ -650,6 +1064,8 @@ const ImageVisionTool = {
 		}
 	}
 };
+/** Structural on purpose: accepts assistants tools/tool calls and agents function tool
+*  calls alike — the check only ever reads `type` and `function.name`. */
 const isImageVisionTool = (tool) => tool.type === "function" && tool.function?.name === ImageVisionTool.function?.name;
 const openAISettings = {
 	model: { default: "gpt-4o-mini" },
@@ -708,8 +1124,45 @@ const getGoogleMaxOutputTokens = (modelName) => {
 	}
 	return GOOGLE_LEGACY_MAX_OUTPUT;
 };
+/**
+* Per-model thinking budget bounds, documented in
+* `com_endpoint_google_thinking_budget`: Gemini 2.5 Pro accepts 128-32,768,
+* Flash accepts 0-24,576, and Flash Lite accepts 512-24,576. The generic
+* 32,000 in the shared definition both under-limits Pro and lets invalid
+* Flash values through.
+*
+* `-1` remains the "decide automatically" sentinel and is not part of these
+* floors. Callers must keep `range.min` at -1 and apply `min` only to
+* non-negative values.
+*/
+const GOOGLE_THINKING_BUDGET_PRO_MAX = 32768;
+const GOOGLE_THINKING_BUDGET_FLASH_MAX = 24576;
+const GOOGLE_THINKING_BUDGET_PRO_MIN = 128;
+const GOOGLE_THINKING_BUDGET_FLASH_MIN = 0;
+const GOOGLE_THINKING_BUDGET_FLASH_LITE_MIN = 512;
+const getGoogleThinkingBudgetBounds = (modelName) => {
+	if (!/gemini-2\.5/i.test(modelName)) return;
+	if (/flash[-_.]?lite/i.test(modelName)) return {
+		min: GOOGLE_THINKING_BUDGET_FLASH_LITE_MIN,
+		max: GOOGLE_THINKING_BUDGET_FLASH_MAX
+	};
+	if (/flash/i.test(modelName)) return {
+		min: GOOGLE_THINKING_BUDGET_FLASH_MIN,
+		max: GOOGLE_THINKING_BUDGET_FLASH_MAX
+	};
+	if (/pro/i.test(modelName)) return {
+		min: GOOGLE_THINKING_BUDGET_PRO_MIN,
+		max: GOOGLE_THINKING_BUDGET_PRO_MAX
+	};
+};
+const getGoogleThinkingBudgetMax = (modelName) => getGoogleThinkingBudgetBounds(modelName)?.max;
 const googleSettings = {
 	model: { default: "gemini-1.5-flash-latest" },
+	maxContextTokens: {
+		min: 10,
+		max: 2e6,
+		step: 1e3
+	},
 	maxOutputTokens: {
 		min: 1,
 		max: GOOGLE_MAX_OUTPUT,
@@ -928,12 +1381,21 @@ const tPluginSchema = zod.z.object({
 	authenticated: zod.z.boolean().optional(),
 	chatMenu: zod.z.boolean().optional(),
 	isButton: zod.z.boolean().optional(),
-	toolkit: zod.z.boolean().optional()
+	toolkit: zod.z.boolean().optional(),
+	/** Raw upstream tool name when the model-facing key stripped a redundant
+	*  server-name prefix — proves upstream identity for legacy id migration. */
+	serverToolName: zod.z.string().optional()
 });
 const tExampleSchema = zod.z.object({
 	input: zod.z.object({ content: zod.z.string() }),
 	output: zod.z.object({ content: zod.z.string() })
 });
+/** Compact context-fading tier persisted beside a message's calibration ratio. */
+const agentFadingTierSchema = zod.z.object({
+	v: zod.z.literal(1),
+	budgetTokens: zod.z.number().positive(),
+	masked: zod.z.boolean()
+});
 const tMessageSchema = zod.z.object({
 	messageId: zod.z.string(),
 	endpoint: zod.z.string().optional(),
@@ -950,6 +1412,12 @@ const tMessageSchema = zod.z.object({
 	/** @deprecated */
 	generation: zod.z.string().nullable().optional(),
 	isCreatedByUser: zod.z.boolean(),
+	/** True when the complete stored row came from outside the model. */
+	isUserSubmitted: zod.z.boolean().optional(),
+	/** JSON pointers to caller-authored fields in an otherwise mixed model response. */
+	userSubmittedPaths: zod.z.array(zod.z.string().startsWith("/")).optional(),
+	/** Exact HITL message-field identity for caller-authored values stored in mixed responses. */
+	userSubmittedMessageFieldPaths: zod.z.array(userSubmittedMessageFieldPathSchema).optional(),
 	isTemporary: zod.z.boolean().optional(),
 	expiredAt: zod.z.string().nullable().optional(),
 	error: zod.z.boolean().optional(),
@@ -969,7 +1437,9 @@ const tMessageSchema = zod.z.object({
 	tokenCount: zod.z.number().optional(),
 	contextMeta: zod.z.object({
 		calibrationRatio: zod.z.number().optional().describe("EMA ratio of provider-reported vs local token estimates; seeds the pruner on subsequent runs"),
-		encoding: zod.z.string().optional().describe("Tokenizer encoding used when this ratio was computed (e.g. \"claude\", \"o200k_base\")")
+		encoding: zod.z.string().optional().describe("Tokenizer encoding used when this ratio was computed (e.g. \"claude\", \"o200k_base\")"),
+		fading: agentFadingTierSchema.optional().describe("Latched context-fading tier of the default agent; seeds the next run so the provider projection of history keeps the same bytes"),
+		fadingTiers: zod.z.array(agentFadingTierSchema.extend({ agentId: zod.z.string().min(1) })).optional().describe("Latched context-fading tiers keyed by agent ID, stored as entries")
 	}).optional(),
 	/**
 	* Skill names the user invoked manually via the `$` popover on this turn.
@@ -1007,6 +1477,19 @@ let MemoryScope = /* @__PURE__ */ function(MemoryScope) {
 	MemoryScope["agent"] = "agent";
 	return MemoryScope;
 }({});
+/** Catalog exposure for a persisted agent with skills enabled. */
+let SkillsScope = /* @__PURE__ */ function(SkillsScope) {
+	SkillsScope["all"] = "all";
+	SkillsScope["selected"] = "selected";
+	SkillsScope["none"] = "none";
+	return SkillsScope;
+}({});
+/** Resolves explicit and legacy persisted-agent skill catalog states. */
+function resolveAgentSkillsScope(skills, enabled, scope) {
+	if (enabled !== true) return "none";
+	if (scope !== void 0) return scope;
+	return (skills ?? []).length > 0 ? "selected" : "all";
+}
 const coerceNumber = zod.z.union([zod.z.number(), zod.z.string()]).transform((val) => {
 	if (typeof val === "string") return val.trim() === "" ? void 0 : parseFloat(val);
 	return val;
@@ -1019,14 +1502,32 @@ const DocumentType = zod.z.lazy(() => zod.z.union([
 	zod.z.array(zod.z.lazy(() => DocumentType)),
 	zod.z.record(zod.z.lazy(() => DocumentType))
 ]));
+const subagentThreadLineageSchema = zod.z.object({
+	rootConversationId: zod.z.string().min(1),
+	parentConversationId: zod.z.string().min(1),
+	parentMessageId: zod.z.string().min(1),
+	parentToolCallId: zod.z.string().min(1),
+	parentAgentId: zod.z.string().min(1).optional(),
+	subagentType: zod.z.string().min(1),
+	subagentKind: zod.z.enum(["agent", "graph"]),
+	depth: zod.z.number().int().positive()
+});
 const tConversationSchema = zod.z.object({
 	conversationId: zod.z.string().nullable(),
 	endpoint: eModelEndpointSchema.nullable(),
 	endpointType: eModelEndpointSchema.nullable().optional(),
 	isArchived: zod.z.boolean().optional(),
+	/** When the chat was archived; absent on chats archived before this was recorded. */
+	archivedAt: zod.z.string().nullable().optional(),
 	pinned: zod.z.boolean().optional(),
 	/** Server-derived: an active shared link exists for this conversation. Not persisted. */
 	isShared: zod.z.boolean().optional(),
+	codeApprovalMode: zod.z.enum(CODE_APPROVAL_MODES).optional(),
+	codeEnvironmentMode: zod.z.enum(CODE_ENVIRONMENT_MODES).optional(),
+	codeWorkspaces: zod.z.array(zod.z.object({
+		environmentId: zod.z.string().regex(CODE_WORKSPACE_ID_PATTERN),
+		workspaceId: zod.z.string().regex(CODE_WORKSPACE_ID_PATTERN)
+	}).strict()).optional(),
 	title: zod.z.string().nullable().or(zod.z.literal("New Chat")).default("New Chat"),
 	user: zod.z.string().optional(),
 	messages: zod.z.array(zod.z.string()).optional(),
@@ -1075,6 +1576,8 @@ const tConversationSchema = zod.z.object({
 	disableStreaming: zod.z.boolean().optional(),
 	assistant_id: zod.z.string().optional(),
 	agent_id: zod.z.string().optional(),
+	/** Durable parent/child navigation for a subagent thread. */
+	subagentThread: subagentThreadLineageSchema.optional(),
 	region: zod.z.string().optional(),
 	maxTokens: coerceNumber.optional(),
 	additionalModelRequestFields: DocumentType.optional(),
@@ -1230,6 +1733,26 @@ const tModelSpecPresetSchema = tPresetSchema.omit({
 	chatGptLabel: true,
 	presetOverride: true,
 	spec: true
+}).merge(zod.z.object({ 
+/**
+* Optional here, unlike `tPresetSchema`, where the key is required (though
+* nullable). A preset naming an `agent_id` has an unambiguous endpoint, so
+* config may omit it and `resolveModelSpecEndpoint` infers `agents` when
+* specs are materialized at config load.
+*/
+endpoint: extendedModelEndpointSchema.nullish() })).superRefine((preset, ctx) => {
+	/**
+	* Omission is only legal when the endpoint is inferable, which requires a
+	* NON-EMPTY `agent_id` — form-backed writers persist untouched fields as
+	* `''`, which names no agent. An explicit `endpoint: null` stays accepted:
+	* it validated before the key became optional, so rejecting it now would
+	* break previously valid configs.
+	*/
+	if (preset.endpoint === void 0 && !preset.agent_id) ctx.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		path: ["endpoint"],
+		message: "endpoint is required unless the preset names a non-empty agent_id (the agents endpoint is then inferred)"
+	});
 });
 const tSharedLinkSchema = zod.z.object({
 	conversationId: zod.z.string(),
@@ -1258,6 +1781,7 @@ const googleBaseSchema = tConversationSchema.pick({
 	examples: true,
 	temperature: true,
 	maxOutputTokens: true,
+	resendFiles: true,
 	artifacts: true,
 	topP: true,
 	topK: true,
@@ -1516,15 +2040,39 @@ const requiredSettingFields = [
 	"type",
 	"component"
 ];
+function clampSettingRange(value, range) {
+	if (range.positiveMin != null) {
+		/** The minimum carries its own meaning here (Google's -1 for automatic),
+		*  and the schema admits it outright, so it survives rather than being
+		*  lifted to the floor. It need not be negative to be the sentinel. */
+		if (value === range.min) return range.min;
+		/** Below the sentinel there is nothing admissible to lift to, so the value
+		*  resolves to it. Between the sentinel and the floor, the floor is the
+		*  nearest value the generated schema accepts. */
+		if (value < Math.max(range.min, 0)) return range.min;
+		return Math.min(Math.max(value, range.positiveMin), range.max);
+	}
+	return Math.min(Math.max(value, range.min), range.max);
+}
 function generateDynamicSchema(settings) {
 	const schemaFields = {};
 	for (const setting of settings) {
 		const { key, type, default: defaultValue, range, options, minText, maxText, minTags, maxTags } = setting;
 		if (type === "number") {
-			let schema = zod.z.number();
+			let numberSchema = zod.z.number();
 			if (range) {
-				schema = schema.min(range.min);
-				schema = schema.max(range.max);
+				numberSchema = numberSchema.min(range.min);
+				numberSchema = numberSchema.max(range.max);
+			}
+			/** Widened deliberately: refine returns ZodEffects, not ZodNumber, and
+			*  the number-specific chaining is already done above. */
+			let schema = numberSchema;
+			if (range?.positiveMin != null) {
+				/** Mirrors clampSettingRange so the generated schema and the clamp
+				*  agree: `min` only admits the sentinel, and any non-negative value
+				*  must clear the documented floor. */
+				const { positiveMin, min } = range;
+				schema = numberSchema.refine((value) => value === min || value >= positiveMin, `Expected ${min} or a value of at least ${positiveMin}`);
 			}
 			if (typeof defaultValue === "number") schemaFields[key] = schema.default(defaultValue);
 			else schemaFields[key] = schema;
@@ -1666,7 +2214,14 @@ function validateSettingDefinitions(settings) {
 			setting.includeInput = setting.type === "number" ? setting.includeInput ?? true : false;
 		}
 		if (setting.component === "slider" && setting.type === "number") {
-			if (setting.default === void 0 && setting.range) setting.default = Math.round((setting.range.min + setting.range.max) / 2);
+			if (setting.default === void 0 && setting.range) {
+				/** The midpoint of the admissible interval, which a positive floor
+				*  narrows: the span between the sentinel and that floor holds no value
+				*  the generated schema accepts, so a midpoint taken across it would
+				*  fail the validation below. */
+				const floor = Math.max(setting.range.min, setting.range.positiveMin ?? setting.range.min);
+				setting.default = Math.round((floor + setting.range.max) / 2);
+			}
 		}
 		if (setting.component === "checkbox" || setting.component === "switch") {
 			if (setting.options && setting.options.length > 2) errors.push({
@@ -1744,6 +2299,16 @@ function validateSettingDefinitions(settings) {
 			message: `Invalid default value for setting ${setting.key}. Must be within the range [${setting.range.min}, ${setting.range.max}].`,
 			path: ["default"]
 		});
+		if (setting.type === "number" && setting.range?.positiveMin != null && setting.range.positiveMin > setting.range.max) errors.push({
+			code: zod.ZodIssueCode.custom,
+			message: `Invalid range for setting ${setting.key}. positiveMin (${setting.range.positiveMin}) cannot exceed max (${setting.range.max}).`,
+			path: ["range"]
+		});
+		if (setting.type === "number" && setting.range?.positiveMin != null && typeof setting.default === "number" && setting.default !== setting.range.min && setting.default < setting.range.positiveMin) errors.push({
+			code: zod.ZodIssueCode.custom,
+			message: `Invalid default value for setting ${setting.key}. Must be ${setting.range.min} or at least ${setting.range.positiveMin}.`,
+			path: ["default"]
+		});
 		if (setting.enumMappings && setting.type === "enum" && setting.options) {
 			for (const option of setting.options) if (!(option in setting.enumMappings)) errors.push({
 				code: zod.ZodIssueCode.custom,
@@ -1845,13 +2410,84 @@ const generateGoogleSchema = (customGoogle) => {
 //#region src/limits.ts
 /** Maximum number of explicit subagents per parent agent. UI + Zod schema share this. */
 const MAX_SUBAGENTS = 10;
+/** Hard upper bound for `endpoints.agents.maxSubagents`, keeping the request-validation
+*  cap bounded no matter what the config file says. */
+const MAX_SUBAGENTS_CEILING = 50;
+let maxSubagents = 10;
+/** Effective subagents-per-agent cap; initialized from `endpoints.agents.maxSubagents` at startup. */
+const getMaxSubagents = () => maxSubagents;
+/** Applies a configured cap; any missing or out-of-range value resets to the default. */
+const setMaxSubagents = (value) => {
+	maxSubagents = typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 50 ? value : 10;
+};
+/** Chat project field limits. The dialogs and the persistence layer share these,
+*  so the inputs stop at the same point the server would otherwise truncate. */
+const MAX_CHAT_PROJECT_NAME_LENGTH = 100;
+const MAX_CHAT_PROJECT_DESCRIPTION_LENGTH = 1e3;
+/** Mirrors the bounded graph-child member limit in `@librechat/agents`. */
+const MAX_GRAPH_SUBAGENT_MEMBERS = 32;
 //#endregion
 //#region src/models.ts
 const modelSpecSubagentsSchema = zod.z.object({
 	enabled: zod.z.boolean().optional(),
 	allowSelf: zod.z.boolean().optional(),
-	agent_ids: zod.z.array(zod.z.string()).max(10).optional()
+	shareFiles: zod.z.boolean().optional(),
+	agent_ids: zod.z.array(zod.z.string()).optional()
+}).superRefine((subagents, ctx) => {
+	const maxSubagents = getMaxSubagents();
+	if ((subagents.agent_ids?.length ?? 0) > maxSubagents) ctx.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		path: ["agent_ids"],
+		message: `agent_ids must contain at most ${maxSubagents} item(s)`
+	});
 });
+function resolveModelSpecEndpoint(modelSpec) {
+	const preset = modelSpec?.preset;
+	if (preset?.endpoint != null) return preset.endpoint;
+	/**
+	* An explicit `endpoint: null` is a statement, not an omission — such specs
+	* validated (and were skipped downstream) before inference existed, so
+	* inferring here would silently activate them. Only an absent key infers,
+	* and only from a non-empty `agent_id`: form-backed writers persist
+	* untouched fields as `''`, which names no agent.
+	*/
+	if (preset?.endpoint === null) return;
+	return preset?.agent_id ? "agents" : void 0;
+}
+/**
+* Writes each spec's resolved endpoint back onto its preset so every consumer —
+* endpoint matching, the selector, access filters, startup presets, provider-key
+* reachability — reads a complete spec instead of re-deriving it. Apply once
+* where the effective config is assembled (YAML load and DB-override merge);
+* downstream code then needs no awareness of inference.
+*
+* Returns the original object, and the original spec objects, when nothing
+* needs filling in, so cached configs and memoized consumers see no new
+* identities.
+*/
+function materializeModelSpecEndpoints(modelSpecs) {
+	const list = modelSpecs?.list;
+	if (!list?.length) return modelSpecs;
+	let changed = false;
+	const materialized = list.map((spec) => {
+		if (spec?.preset == null || spec.preset.endpoint != null) return spec;
+		const endpoint = resolveModelSpecEndpoint(spec);
+		if (endpoint == null) return spec;
+		changed = true;
+		return {
+			...spec,
+			preset: {
+				...spec.preset,
+				endpoint
+			}
+		};
+	});
+	if (!changed) return modelSpecs;
+	return {
+		...modelSpecs,
+		list: materialized
+	};
+}
 const tModelSpecSchema = zod.z.object({
 	name: zod.z.string(),
 	label: zod.z.string(),
@@ -2077,6 +2713,49 @@ const bedrockDocumentFormats = {
 	"text/plain": "txt",
 	"text/markdown": "md"
 };
+/**
+* Whether an upload belongs to the conversation rather than to the agent. The value
+* arrives from multipart form data, so it can be the string "false", which is truthy.
+* Shared so the route, the authorization check and processing cannot disagree about it.
+*/
+const isMessageFileUpload = (value) => value === true || value === "true";
+/**
+* Whether the upload's conversation uses the Responses API, which decides whether Azure
+* can carry a document natively. Multipart form data has no booleans, so it arrives as
+* the string "true".
+*/
+const isResponsesApiUpload = (value) => value === true || value === "true";
+/**
+* The name a file carries inside the code sandbox.
+*
+* Image uploads are converted to the configured output type while the record keeps the
+* original filename, so the extension has to follow the stored bytes or the sandbox
+* decoder is handed a mismatch. Provisioning and priming both resolve the mount path
+* from here: deriving it twice under different rules leaves a later turn advertising a
+* path that does not exist in the sandbox.
+*/
+const resolveSandboxFilename = (filename, mimeType) => {
+	if (!mimeType?.startsWith("image/")) return filename;
+	const subtype = mimeType.slice(6);
+	if (![
+		"webp",
+		"png",
+		"jpeg",
+		"gif"
+	].includes(subtype)) return filename;
+	const accepted = subtype === "jpeg" ? [".jpg", ".jpeg"] : [`.${subtype}`];
+	const lastDot = filename.lastIndexOf(".");
+	const currentExt = lastDot > 0 ? filename.slice(lastDot).toLowerCase() : "";
+	if (accepted.includes(currentExt)) return filename;
+	return `${lastDot > 0 ? filename.slice(0, lastDot) : filename}${accepted[0]}`;
+};
+/**
+* The Responses setting a turn actually runs on. A saved agent's own record wins, since
+* execution reads its model parameters; a conversation only answers for itself. Upload
+* and delivery must agree here, or a document is stored as raw provider content and then
+* re-resolved to text it has no extraction for.
+*/
+const resolveUseResponsesApi = (agentValue, conversationValue) => agentValue ?? conversationValue ?? void 0;
 const isBedrockDocumentType = (mimeType) => mimeType != null && mimeType in bedrockDocumentFormats;
 /** MIME types Bedrock's Converse document path can send to the model (mirrors `bedrockDocumentFormats`). */
 const bedrockDocumentMimeTypes = Object.keys(bedrockDocumentFormats);
@@ -2310,6 +2989,8 @@ const mbToBytes = (mb) => mb * megabyte;
 const defaultSizeLimit = mbToBytes(512);
 const defaultSkillImportSizeLimit = mbToBytes(50);
 const defaultTokenLimit = 1e5;
+const defaultContextSizeLimit = mbToBytes(128);
+const defaultContextCharLimit = 1e6;
 const assistantsFileConfig = {
 	fileLimit: 10,
 	fileSizeLimit: defaultSizeLimit,
@@ -2341,11 +3022,14 @@ const fileConfig = {
 	serverFileSizeLimit: defaultSizeLimit,
 	avatarSizeLimit: mbToBytes(2),
 	fileTokenLimit: defaultTokenLimit,
+	fileContextSizeLimit: defaultContextSizeLimit,
+	fileContextCharLimit: defaultContextCharLimit,
 	clientImageResize: {
 		enabled: false,
 		maxWidth: 1900,
 		maxHeight: 1900,
-		quality: .92
+		quality: .92,
+		enforced: false
 	},
 	ocr: { supportedMimeTypes: defaultOCRMimeTypes },
 	text: { supportedMimeTypes: defaultTextMimeTypes },
@@ -2355,12 +3039,23 @@ const fileConfig = {
 	}
 };
 const supportedMimeTypesSchema = zod.z.array(zod.z.string()).optional();
+const DefaultLLMDeliveryPath = zod.z.enum([
+	"provider",
+	"text",
+	"none"
+]);
+const defaultLLMDeliveryPathSchema = zod.z.object({
+	fallback: DefaultLLMDeliveryPath.optional(),
+	overrides: zod.z.record(DefaultLLMDeliveryPath).optional()
+});
 const endpointFileConfigSchema = zod.z.object({
 	disabled: zod.z.boolean().optional(),
 	fileLimit: zod.z.number().min(0).optional(),
 	fileSizeLimit: zod.z.number().min(0).optional(),
 	totalSizeLimit: zod.z.number().min(0).optional(),
-	supportedMimeTypes: supportedMimeTypesSchema.optional()
+	supportedMimeTypes: supportedMimeTypesSchema.optional(),
+	defaultLLMDeliveryPath: defaultLLMDeliveryPathSchema.optional(),
+	legacyFileUploadUX: zod.z.boolean().optional()
 });
 const skillFileConfigSchema = zod.z.object({ fileSizeLimit: zod.z.number().min(0).optional() });
 const fileConfigSchema = zod.z.object({
@@ -2369,18 +3064,23 @@ const fileConfigSchema = zod.z.object({
 	serverFileSizeLimit: zod.z.number().min(0).optional(),
 	avatarSizeLimit: zod.z.number().min(0).optional(),
 	fileTokenLimit: zod.z.number().min(0).optional(),
+	fileContextSizeLimit: zod.z.number().min(0).optional(),
+	fileContextCharLimit: zod.z.number().min(0).optional(),
+	codeEnvLivenessSafeWindowMs: zod.z.number().min(0).optional(),
 	imageGeneration: zod.z.object({
 		percentage: zod.z.number().min(0).max(100).optional(),
 		px: zod.z.number().min(0).optional()
 	}).optional(),
 	clientImageResize: zod.z.object({
 		enabled: zod.z.boolean().optional(),
-		maxWidth: zod.z.number().min(0).optional(),
-		maxHeight: zod.z.number().min(0).optional(),
+		maxWidth: zod.z.number().min(1).optional(),
+		maxHeight: zod.z.number().min(1).optional(),
 		quality: zod.z.number().min(0).max(1).optional()
 	}).optional(),
 	ocr: zod.z.object({ supportedMimeTypes: supportedMimeTypesSchema.optional() }).optional(),
-	text: zod.z.object({ supportedMimeTypes: supportedMimeTypesSchema.optional() }).optional()
+	text: zod.z.object({ supportedMimeTypes: supportedMimeTypesSchema.optional() }).optional(),
+	defaultLLMDeliveryPath: defaultLLMDeliveryPathSchema.optional(),
+	legacyFileUploadUX: zod.z.boolean().optional()
 });
 /**
 * Compiler for admin-supplied MIME patterns. Defaults to native `RegExp`, which browser
@@ -2516,6 +3216,12 @@ const documentMimeExtensions = [
 	["text/calendar", [".ics"]],
 	["message/rfc822", [".eml"]]
 ];
+/** Preferred extension for a known document MIME type, including its leading dot. */
+function getDocumentFileExtension(mimeType) {
+	const normalized = mimeType?.split(";", 1)[0].trim().toLowerCase();
+	const canonical = normalized === "text/comma-separated-values" ? "text/csv" : normalized;
+	return documentMimeExtensions.find(([type]) => type === canonical)?.[1][0];
+}
 const documentMimeSet = new Set(documentMimeExtensions.map(([mimeType]) => mimeType));
 /** Every MIME type LibreChat may accept, used to detect patterns that reach beyond the representable set. */
 const knownMimeUniverse = Array.from(new Set([
@@ -2609,7 +3315,45 @@ function mergeWithDefault(endpointConfig, defaultConfig, endpoint) {
 		fileLimit: endpointConfig.fileLimit ?? defaultConfig.fileLimit,
 		fileSizeLimit: endpointConfig.fileSizeLimit ?? defaultConfig.fileSizeLimit,
 		totalSizeLimit: endpointConfig.totalSizeLimit ?? defaultConfig.totalSizeLimit,
-		supportedMimeTypes: endpointConfig.supportedMimeTypes ?? defaultMimeTypes
+		supportedMimeTypes: endpointConfig.supportedMimeTypes ?? defaultMimeTypes,
+		defaultLLMDeliveryPath: mergeDeliveryPathConfig(endpointConfig.defaultLLMDeliveryPath, defaultConfig.defaultLLMDeliveryPath),
+		legacyFileUploadUX: endpointConfig.legacyFileUploadUX ?? defaultConfig.legacyFileUploadUX
+	};
+}
+/**
+* Deep-merges delivery-path config so an endpoint that supplies only one override
+* still inherits the default's fallback and shared overrides. Whole-object
+* replacement would silently drop the inherited routing.
+*/
+function mergeDeliveryPathConfig(endpointValue, defaultValue) {
+	if (!endpointValue) return defaultValue;
+	if (!defaultValue) return endpointValue;
+	if (endpointValue.fallback != null) return endpointValue;
+	const hasOverrides = endpointValue.overrides != null || defaultValue.overrides != null;
+	return {
+		...defaultValue.fallback != null ? { fallback: defaultValue.fallback } : {},
+		...hasOverrides ? { overrides: { ...shadowByWildcard(defaultValue.overrides, endpointValue.overrides) } } : {}
+	};
+}
+/**
+* Flattens two override layers into one map that still resolves like the layered chain.
+* Resolution reads exact keys before wildcards, so a plain spread would let a lower
+* layer's `image/png` outrank the upper layer's `image/*`. Dropping the entries an
+* upper wildcard covers restores precedence without changing how lookups work.
+*/
+function shadowByWildcard(lower, upper) {
+	if (!lower) return { ...upper };
+	const upperWildcards = /* @__PURE__ */ new Set();
+	for (const key in upper) if (key.endsWith("/*")) upperWildcards.add(key.slice(0, -1));
+	if (upperWildcards.size === 0) return {
+		...lower,
+		...upper
+	};
+	const retained = {};
+	for (const key in lower) if (!(!key.endsWith("/*") && upperWildcards.has(key.slice(0, key.indexOf("/") + 1)) && upper?.[key] == null)) retained[key] = lower[key];
+	return {
+		...retained,
+		...upper
 	};
 }
 function getEndpointFileConfig(params) {
@@ -2617,8 +3361,13 @@ function getEndpointFileConfig(params) {
 	if (!mergedFileConfig?.endpoints) return fileConfig.endpoints.default;
 	/** Compute an effective default by merging user-configured default over the base default */
 	const baseDefaultConfig = fileConfig.endpoints.default;
+	const globalDefaultConfig = {
+		...baseDefaultConfig,
+		defaultLLMDeliveryPath: mergeDeliveryPathConfig(mergedFileConfig.defaultLLMDeliveryPath, baseDefaultConfig.defaultLLMDeliveryPath),
+		legacyFileUploadUX: mergedFileConfig.legacyFileUploadUX ?? baseDefaultConfig.legacyFileUploadUX
+	};
 	const userDefaultConfig = mergedFileConfig.endpoints.default;
-	const defaultConfig = userDefaultConfig ? mergeWithDefault(userDefaultConfig, baseDefaultConfig, "default") : baseDefaultConfig;
+	const defaultConfig = userDefaultConfig ? mergeWithDefault(userDefaultConfig, globalDefaultConfig, "default") : globalDefaultConfig;
 	const normalizedEndpoint = normalizeEndpointName(endpoint ?? "");
 	const standardEndpoints = new Set([
 		"default",
@@ -2673,16 +3422,21 @@ function mergeFileConfig(dynamic) {
 		}
 	};
 	if (!dynamic) return mergedConfig;
+	if (dynamic.defaultLLMDeliveryPath !== void 0) mergedConfig.defaultLLMDeliveryPath = dynamic.defaultLLMDeliveryPath;
+	if (dynamic.legacyFileUploadUX !== void 0) mergedConfig.legacyFileUploadUX = dynamic.legacyFileUploadUX;
 	if (dynamic.serverFileSizeLimit !== void 0) mergedConfig.serverFileSizeLimit = mbToBytes(dynamic.serverFileSizeLimit);
 	if (dynamic.avatarSizeLimit !== void 0) mergedConfig.avatarSizeLimit = mbToBytes(dynamic.avatarSizeLimit);
 	if (dynamic.fileTokenLimit !== void 0) mergedConfig.fileTokenLimit = dynamic.fileTokenLimit;
+	if (dynamic.fileContextSizeLimit !== void 0) mergedConfig.fileContextSizeLimit = mbToBytes(dynamic.fileContextSizeLimit);
+	if (dynamic.fileContextCharLimit !== void 0) mergedConfig.fileContextCharLimit = dynamic.fileContextCharLimit;
 	if (dynamic.skills?.fileSizeLimit !== void 0) mergedConfig.skills = {
 		...mergedConfig.skills,
 		fileSizeLimit: mbToBytes(dynamic.skills.fileSizeLimit)
 	};
 	if (dynamic.clientImageResize !== void 0) mergedConfig.clientImageResize = {
 		...mergedConfig.clientImageResize,
-		...dynamic.clientImageResize
+		...dynamic.clientImageResize,
+		enforced: dynamic.clientImageResize.enabled !== void 0
 	};
 	if (dynamic.ocr !== void 0) {
 		const { supportedMimeTypes: ocrMimeTypes, ...ocrRest } = dynamic.ocr;
@@ -2722,6 +3476,8 @@ function mergeFileConfig(dynamic) {
 		});
 		if (dynamicEndpoint.disabled !== void 0) mergedEndpoint.disabled = dynamicEndpoint.disabled;
 		if (dynamicEndpoint.supportedMimeTypes) mergedEndpoint.supportedMimeTypes = convertStringsToRegex(dynamicEndpoint.supportedMimeTypes);
+		if (dynamicEndpoint.defaultLLMDeliveryPath !== void 0) mergedEndpoint.defaultLLMDeliveryPath = dynamicEndpoint.defaultLLMDeliveryPath;
+		if (dynamicEndpoint.legacyFileUploadUX !== void 0) mergedEndpoint.legacyFileUploadUX = dynamicEndpoint.legacyFileUploadUX;
 	}
 	return mergedConfig;
 }
@@ -2743,9 +3499,15 @@ const buildQuery = (params) => {
 };
 const health = () => `${BASE_URL}/health`;
 const user = () => `${BASE_URL}/api/user`;
+const userPreferences = () => `${user()}/preferences`;
 const balance = () => `${BASE_URL}/api/balance`;
 const userPlugins = () => `${BASE_URL}/api/user/plugins`;
 const deleteUser$1 = () => `${BASE_URL}/api/user/delete`;
+const codeEnvironments = () => `${BASE_URL}/api/code-environments`;
+const codeEnvironmentPairings = () => `${codeEnvironments()}/pairings`;
+const codeEnvironmentById = (id) => `${codeEnvironments()}/${encodeURIComponent(id)}`;
+const codeEnvironmentSettings = (id) => `${codeEnvironmentById(id)}/settings`;
+const codeEnvironmentStatus = (id) => `${codeEnvironmentById(id)}/status`;
 const messagesRoot = `${BASE_URL}/api/messages`;
 const messages = (params) => {
 	const { conversationId, messageId, ...rest } = params;
@@ -2786,9 +3548,17 @@ const conversations = (params) => {
 	return `${conversationsRoot}${buildQuery(params)}`;
 };
 const conversationById = (id) => `${conversationsRoot}/${id}`;
+const parentSubagents = (parentConversationId) => `${conversationsRoot}/${encodeURIComponent(parentConversationId)}/subagents`;
+const subagentThread = (parentConversationId, threadId, taskId, cursor) => {
+	const endpoint = `${conversationsRoot}/${encodeURIComponent(parentConversationId)}/subagents/${encodeURIComponent(threadId)}`;
+	if (taskId != null) return `${endpoint}?taskId=${encodeURIComponent(taskId)}`;
+	return cursor == null ? endpoint : `${endpoint}?cursor=${encodeURIComponent(cursor)}`;
+};
+const subagentControl = (parentConversationId, threadId) => `${conversationsRoot}/${encodeURIComponent(parentConversationId)}/subagents/${encodeURIComponent(threadId)}/control`;
 const genTitle$1 = (conversationId) => `${conversationsRoot}/gen_title/${encodeURIComponent(conversationId)}`;
 const updateConversation$1 = () => `${conversationsRoot}/update`;
 const archiveConversation$1 = () => `${conversationsRoot}/archive`;
+const archiveAllConversations$1 = () => `${conversationsRoot}/archive/all`;
 const pinConversation$1 = () => `${conversationsRoot}/pin`;
 const deleteConversation$1 = () => `${conversationsRoot}`;
 const deleteAllConversation = () => `${conversationsRoot}/all`;
@@ -2873,6 +3643,14 @@ const agents = ({ path = "", options }) => {
 	return url;
 };
 const activeJobs = () => `${BASE_URL}/api/agents/chat/active`;
+const agentQueuedTurnsRoot = `${BASE_URL}/api/agents/chat/queued-turns`;
+const agentQueuedTurns = () => agentQueuedTurnsRoot;
+const agentQueuedTurnsByConversation = (conversationId, clientRequestIds = []) => {
+	const uniqueIds = Array.from(new Set(clientRequestIds)).slice(0, 100);
+	const knownIds = uniqueIds.length > 0 ? `&${uniqueIds.map((id) => `clientRequestIds=${encodeURIComponent(id)}`).join("&")}` : "";
+	return `${agentQueuedTurnsRoot}?conversationId=${encodeURIComponent(conversationId)}${knownIds}`;
+};
+const agentQueuedTurn = (queuedTurnId) => `${agentQueuedTurnsRoot}/${encodeURIComponent(queuedTurnId)}`;
 const mcp = {
 	tools: `${BASE_URL}/api/mcp/tools`,
 	servers: `${BASE_URL}/api/mcp/servers`
@@ -2926,6 +3704,9 @@ const deletePrompt$1 = ({ _id, groupId }) => {
 };
 const getCategories$1 = () => `${BASE_URL}/api/categories`;
 const getAllPromptGroups$1 = () => `${prompts()}/all`;
+const schedules = () => `${BASE_URL}/api/schedules`;
+const schedule = (id) => `${schedules()}/${encodeURIComponent(id)}`;
+const runSchedule = (id) => `${schedule(id)}/run`;
 const skills = () => `${BASE_URL}/api/skills`;
 const importSkill$1 = () => `${skills()}/import`;
 const getSkill$1 = (id) => `${skills()}/${encodeURIComponent(id)}`;
@@ -2939,6 +3720,15 @@ const listSkillsWithFilters = (filter) => {
 };
 const skillFiles = (id) => `${getSkill$1(id)}/files`;
 const skillFile = (id, relativePath) => `${skillFiles(id)}/${encodeURIComponent(relativePath)}`;
+const insights = () => `${BASE_URL}/api/insights`;
+const insightsAccess = () => `${insights()}/access`;
+const conversationTrace = (conversationId) => `${BASE_URL}/api/traces/${encodeURIComponent(conversationId)}`;
+const conversationTraceAvailability = (conversationId) => `${conversationTrace(conversationId)}/availability`;
+const conversationTraceRecords = (conversationId, cursor) => `${conversationTrace(conversationId)}/records${cursor ? `?${new URLSearchParams({ cursor }).toString()}` : ""}`;
+const conversationTraceRecord = (conversationId, recordId, messageId, sourceId) => `${conversationTrace(conversationId)}/records/${encodeURIComponent(recordId)}?${new URLSearchParams({
+	message: messageId,
+	...sourceId ? { source: sourceId } : {}
+}).toString()}`;
 const adminSkillsSync = () => `${BASE_URL}/api/admin/skills/sync`;
 const adminSkillsSyncStatus = () => `${adminSkillsSync()}/status`;
 const adminSkillsSyncRun = () => `${adminSkillsSync()}/run`;
@@ -2947,6 +3737,7 @@ const skillStates = () => `${BASE_URL}/api/user/settings/skills/active`;
 const adminLangfuseConnection = () => `${BASE_URL}/api/admin/langfuse/connection`;
 const adminLangfuseConnectionTest = () => `${adminLangfuseConnection()}/test`;
 const adminLangfuseSessionLink = (conversationId) => `${adminLangfuseConnection()}/session/${encodeURIComponent(conversationId)}`;
+const pinnedOrder = () => `${BASE_URL}/api/user/settings/pinned-order`;
 const toolFavorites = () => `${BASE_URL}/api/user/settings/favorites/tools`;
 const toolFavorite = (itemType, itemId) => `${toolFavorites()}/${itemType}/${encodeURIComponent(itemId)}`;
 const roles = () => `${BASE_URL}/api/roles`;
@@ -2974,6 +3765,7 @@ const regenerateBackupCodes$1 = () => `${BASE_URL}/api/auth/2fa/backup/regenerat
 const verifyTwoFactorTemp$1 = () => `${BASE_URL}/api/auth/2fa/verify-temp`;
 const memories = () => `${BASE_URL}/api/memories`;
 const memory = (key, agentId) => `${memories()}/${encodeURIComponent(key)}${agentId ? `?agentId=${encodeURIComponent(agentId)}` : ""}`;
+const memoryById = (id, agentId) => `${memories()}/id/${encodeURIComponent(id)}${agentId ? `?agentId=${encodeURIComponent(agentId)}` : ""}`;
 const memoryPreferences = () => `${memories()}/preferences`;
 const searchPrincipals$1 = (params) => {
 	const { q: query, limit, types } = params;
@@ -3017,6 +3809,7 @@ let FileContext = /* @__PURE__ */ function(FileContext) {
 	FileContext["image_generation"] = "image_generation";
 	FileContext["assistants_output"] = "assistants_output";
 	FileContext["message_attachment"] = "message_attachment";
+	FileContext["run_artifact"] = "run_artifact";
 	FileContext["skill_file"] = "skill_file";
 	FileContext["filename"] = "filename";
 	FileContext["updatedAt"] = "updatedAt";
@@ -3047,6 +3840,12 @@ let TokenExchangeMethodEnum = /* @__PURE__ */ function(TokenExchangeMethodEnum)
 }({});
 //#endregion
 //#region src/mcp.ts
+/**
+* Upper bound on a stored MCP `iconPath` (URL or data URI). Enforced by
+* `sanitizeMcpIconPath`, not a schema `.max()`, so re-submitting a server whose
+* stored icon predates the cap clears the icon instead of rejecting the update.
+*/
+const MAX_MCP_ICON_PATH_LENGTH = 256 * 1024;
 const validateOAuthClientCredentials = (oauth, ctx) => {
 	if (oauth.client_secret && !oauth.client_id) ctx.addIssue({
 		code: zod.z.ZodIssueCode.custom,
@@ -3151,9 +3950,11 @@ const UserOAuthOptionsSchema = OAuthOptionsBaseSchema.omit({
 const OboOptionsSchema = zod.z.object({ 
 /** Scopes to request for the downstream MCP server (e.g., "api://<client-id>/Mcp.Tools.ReadWrite") */
 scopes: zod.z.string().min(1) });
+const MCP_SERVER_TITLE_PATTERN = /* @__PURE__ */ new RegExp("^[\\p{L}\\p{N}][\\p{L}\\p{N}\\p{M}'’ -]*$", "u");
+const MCP_SERVER_TITLE_ERROR = "Title must start with a letter or number and can include spaces, hyphens, and apostrophes";
 const BaseOptionsSchema = zod.z.object({
-	/** Display name for the MCP server - only letters, numbers, and spaces allowed */
-	title: zod.z.string().regex(/^[a-zA-Z0-9 ]+$/, "Title can only contain letters, numbers, and spaces").optional(),
+	/** Display name for the MCP server */
+	title: zod.z.string().regex(MCP_SERVER_TITLE_PATTERN, MCP_SERVER_TITLE_ERROR).optional(),
 	/** Description of the MCP server */
 	description: zod.z.string().optional(),
 	/**
@@ -3168,7 +3969,14 @@ const BaseOptionsSchema = zod.z.object({
 	/** Timeout (ms) for the long-lived SSE GET stream body before undici aborts it. Default: 300_000 (5 min). */
 	sseReadTimeout: zod.z.number().int().positive().optional(),
 	initTimeout: zod.z.number().int().nonnegative().optional(),
-	/** Controls visibility in chat dropdown menu (MCPSelect) */
+	/**
+	* Whether the server is offered in chat.
+	*
+	* `false` hides it from the chat dropdown (MCPSelect) AND bars it from the
+	* chat selection a request carries, so a stale or hand-written request cannot
+	* reach it either. It does not restrict agents, nor a server a model spec
+	* pins through `mcpServers` — both are the operator's own choice.
+	*/
 	chatMenu: zod.z.boolean().optional(),
 	/**
 	* Controls server instruction behavior:
@@ -3224,6 +4032,26 @@ const ProxyUrlSchema = zod.z.string().transform((val) => extractEnvVariable(val)
 	const protocol = new URL(val).protocol;
 	return protocol === "http:" || protocol === "https:" || protocol === "socks:" || protocol === "socks5:";
 }, { message: "Proxy URL must use http://, https://, socks://, or socks5://" });
+const PROCESS_MCP_SERVER_FIELDS = new Set([
+	"command",
+	"args",
+	"env",
+	"cwd",
+	"stderr"
+]);
+function isProcessMCPServerField(field) {
+	return PROCESS_MCP_SERVER_FIELDS.has(field);
+}
+function isProcessMCPServerConfig(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	const config = value;
+	if (config.type === "stdio") return true;
+	return Object.keys(config).some(isProcessMCPServerField);
+}
+function hasProcessMCPServerConfig(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	return Object.values(value).some(isProcessMCPServerConfig);
+}
 const StdioOptionsSchema = BaseOptionsSchema.extend({
 	type: zod.z.literal("stdio").default("stdio"),
 	obo: zod.z.undefined().optional(),
@@ -3396,7 +4224,7 @@ const defaultSocialLogins = [
 	"discord",
 	"saml"
 ];
-const BASE_ONLY_CONFIG_SECTIONS = [];
+const BASE_ONLY_CONFIG_SECTIONS = ["filters"];
 /** Sections that may be stored in the tenant's base config document but must
 * not be overridden or tombstoned by role, group, or user config documents. */
 const BASE_PRINCIPAL_CONFIG_SECTIONS = ["langfuse"];
@@ -3424,6 +4252,14 @@ const defaultRetrievalModels = [
 ];
 const excludedKeys = new Set([
 	"conversationId",
+	"agentEventBinding",
+	"agentEventActor",
+	"agentEventActorCleanup",
+	"agentEventActorSuspension",
+	"agentEventActorReconciliations",
+	"agentEventActorEpoch",
+	"agentEventActorLegacyTurn",
+	"subagentThread",
 	"title",
 	"iconURL",
 	"greeting",
@@ -3435,6 +4271,8 @@ const excludedKeys = new Set([
 	"isTemporary",
 	"messages",
 	"isArchived",
+	"pinned",
+	"archivedAt",
 	"tags",
 	"user",
 	"__v",
@@ -3824,6 +4662,22 @@ const baseEndpointSchema = zod.z.object({
 	activityPhasePrompt: zod.z.string().optional(),
 	/** Cost cap: maximum phase summaries generated per run. Default 5. */
 	activityPhaseMaxPerRun: zod.z.number().int().positive().optional(),
+	/** Generates a live orientation label for sufficiently long top-level response reasoning. */
+	reasoningLabel: zod.z.boolean().optional(),
+	/** Model used for reasoning labels. Defaults to activityModel, titleModel, then run model. */
+	reasoningLabelModel: zod.z.string().optional(),
+	/** Endpoint receiving the bounded visible-reasoning snapshot. Defaults to activityEndpoint. */
+	reasoningLabelEndpoint: zod.z.string().optional(),
+	/** Overrides the dedicated reasoning-label system prompt. */
+	reasoningLabelPrompt: zod.z.string().optional(),
+	/** Characters required before the first reasoning label. Default 500. */
+	reasoningLabelMinChars: zod.z.number().int().positive().optional(),
+	/** New characters required between streaming revisions. Default 400. */
+	reasoningLabelUpdateChars: zod.z.number().int().positive().optional(),
+	/** Minimum milliseconds between streaming revisions. Default 3000. */
+	reasoningLabelUpdateIntervalMs: zod.z.number().int().nonnegative().optional(),
+	/** Cost cap: maximum reasoning-label provider calls attempted per run. Default 8. */
+	reasoningLabelMaxPerRun: zod.z.number().int().positive().optional(),
 	/** Maximum characters allowed in a single tool result before truncation. */
 	maxToolResultChars: zod.z.number().positive().optional()
 });
@@ -3910,13 +4764,13 @@ function isRemoteOidcUrlAllowed(value) {
 }
 const remoteApiOidcUrlSchema = zod.z.string().url().refine(isRemoteOidcUrlAllowed, { message: "must use https:// unless targeting localhost" });
 const remoteApiOidcScopeSchema = zod.z.string().refine((scope) => !scope.includes(","), { message: "scopes must be space-separated" });
-const remoteApiOidcSchema = zod.z.object({
+const oidcAccessTokenSchema = zod.z.object({
 	enabled: zod.z.boolean().default(false),
 	issuer: remoteApiOidcUrlSchema.optional(),
 	audience: zod.z.string().min(1).optional(),
-	jwksUri: remoteApiOidcUrlSchema.optional(),
-	scope: remoteApiOidcScopeSchema.optional()
-}).superRefine((oidc, ctx) => {
+	jwksUri: remoteApiOidcUrlSchema.optional()
+});
+function validateEnabledOidc(oidc, ctx) {
 	if (oidc.enabled === true && !oidc.issuer) ctx.addIssue({
 		code: zod.z.ZodIssueCode.custom,
 		path: ["issuer"],
@@ -3927,12 +4781,46 @@ const remoteApiOidcSchema = zod.z.object({
 		path: ["audience"],
 		message: "audience is required when OIDC auth is enabled"
 	});
-});
+}
+const remoteApiOidcSchema = oidcAccessTokenSchema.extend({ scope: remoteApiOidcScopeSchema.optional() }).superRefine(validateEnabledOidc);
 const remoteApiAuthSchema = zod.z.object({
 	apiKey: zod.z.object({ enabled: zod.z.boolean().default(true) }).optional(),
 	oidc: remoteApiOidcSchema.optional()
 });
 const remoteApiSchema = zod.z.object({ auth: remoteApiAuthSchema.optional() });
+const managementClientBindingSchema = zod.z.object({
+	clientId: zod.z.string().trim().min(1).max(128),
+	subject: zod.z.string().trim().min(1).max(512).optional(),
+	userId: zod.z.string().trim().regex(/^[a-f\d]{24}$/i, "must be a MongoDB ObjectId").transform((userId) => userId.toLowerCase()),
+	tenantId: zod.z.string().trim().min(1).max(128).regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/, "must be a valid tenant id").refine((tenantId) => tenantId !== "__SYSTEM__", "system tenant is not allowed"),
+	enabled: zod.z.boolean().default(true)
+}).strict();
+const managementApiOidcSchema = oidcAccessTokenSchema.strict().superRefine(validateEnabledOidc);
+const managementApiAuthSchema = zod.z.object({
+	oidc: managementApiOidcSchema,
+	clients: zod.z.array(managementClientBindingSchema).max(100).default([])
+}).strict().superRefine((auth, ctx) => {
+	if (auth.oidc.enabled === true && auth.clients.length === 0) ctx.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		path: ["clients"],
+		message: "at least one client binding is required when management auth is enabled"
+	});
+	const clientIds = /* @__PURE__ */ new Set();
+	for (let index = 0; index < auth.clients.length; index++) {
+		const client = auth.clients[index];
+		if (clientIds.has(client.clientId)) ctx.addIssue({
+			code: zod.z.ZodIssueCode.custom,
+			path: [
+				"clients",
+				index,
+				"clientId"
+			],
+			message: "client IDs must be unique"
+		});
+		clientIds.add(client.clientId);
+	}
+});
+const managementApiSchema = zod.z.object({ auth: managementApiAuthSchema.optional() }).strict();
 /**
 * Permission mode applied to a tool call. Mirrors `@librechat/agents`'s
 * `ToolPolicyMode` 1:1.
@@ -3955,7 +4843,7 @@ const toolApprovalModeSchema = zod.z.enum([
 *
 * Shape mirrors `@librechat/agents`'s `ToolPolicyConfig` so the host can map it
 * directly into `createToolPolicyHook(config)`. The SDK does the evaluation
-* (`deny → bypass → allow → ask → dontAsk → fallthrough(ask)`); this config
+* (`deny → ask → allow → bypass → dontAsk → fallthrough(ask)`); this config
 * just describes the surface.
 *
 * Conventions:
@@ -4038,6 +4926,62 @@ const checkpointerSchema = zod.z.object({
 	checkpointCollectionName: zod.z.string().optional(),
 	checkpointWritesCollectionName: zod.z.string().optional()
 }).optional();
+const codeEnvironmentBaseURLSchema = zod.z.string().trim().url().refine((value) => {
+	try {
+		const url = new URL(value);
+		return (url.protocol === "http:" || url.protocol === "https:") && !value.includes("?") && !value.includes("#") && url.search.length === 0 && url.hash.length === 0;
+	} catch {
+		return false;
+	}
+}, { message: "Code environment baseURL must be an HTTP(S) base URL without query or fragment" });
+function isSecureCodeEnvironmentControlURL(baseURL) {
+	try {
+		const url = new URL(baseURL.trim());
+		if (url.protocol === "https:") return true;
+		if (url.protocol !== "http:") return false;
+		return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+	} catch {
+		return false;
+	}
+}
+const codeEnvironmentPermissionDecisionSchema = zod.z.enum([
+	"allow",
+	"ask",
+	"deny"
+]);
+const codeEnvironmentPermissionFieldSchema = zod.z.object({
+	allowed: zod.z.array(codeEnvironmentPermissionDecisionSchema).min(1),
+	default: codeEnvironmentPermissionDecisionSchema.optional().default("ask")
+}).strict().superRefine((field, context) => {
+	if (!field.allowed.includes(field.default)) context.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		path: ["default"],
+		message: "Permission default must be included in allowed values"
+	});
+});
+/** Existing attached commands used a fixed 30-second execution budget. */
+const CODE_ENVIRONMENT_COMMAND_TIMEOUT_DEFAULT_MS = 3e4;
+/** Protocol-level ceiling; deployments may only lower this value. */
+const CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS = 5 * 6e4;
+/**
+* Typed user-tunable surface for one attached code environment. Omitted fields
+* remain fixed at LibreChat's safe baseline. Isolation, networking, mounts,
+* privileged execution, and secrets are deliberately not representable here.
+*/
+const codeEnvironmentUserConfigSchema = zod.z.object({
+	permissions: zod.z.object({
+		fileWrite: codeEnvironmentPermissionFieldSchema.optional(),
+		commandExecution: codeEnvironmentPermissionFieldSchema.optional()
+	}).strict().optional(),
+	limits: zod.z.object({ 
+	/** Maximum timeout a Bash invocation may request. Omission preserves
+	* the historical 30-second command budget. */
+maxCommandTimeoutMs: zod.z.number().int().min(1).max(CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS).optional() }).strict().optional()
+}).strict();
+const codeEnvironmentUserSettingsSchema = zod.z.object({ permissions: zod.z.object({
+	fileWrite: codeEnvironmentPermissionDecisionSchema.optional(),
+	commandExecution: codeEnvironmentPermissionDecisionSchema.optional()
+}).strict().optional() }).strict();
 const agentsEndpointSchema = baseEndpointSchema.omit({ baseURL: true }).merge(zod.z.object({
 	recursionLimit: zod.z.number().optional(),
 	disableBuilder: zod.z.boolean().optional().default(false),
@@ -4054,9 +4998,150 @@ const agentsEndpointSchema = baseEndpointSchema.omit({ baseURL: true }).merge(zo
 	maxCitations: zod.z.number().min(1).max(50).optional().default(30),
 	maxCitationsPerFile: zod.z.number().min(1).max(10).optional().default(7),
 	minRelevanceScore: zod.z.number().min(0).max(1).optional().default(.45),
+	/** Maximum explicit subagents per agent (`agent_ids` and `graphs`); raised from
+	* the shipped default of 10 for orchestration-heavy deployments, bounded by
+	* `MAX_SUBAGENTS_CEILING`. */
+	maxSubagents: zod.z.number().int().min(1).max(50).optional().default(10),
+	/** Run-scoped file access for explicitly opted-in subagent delegations. */
+	fileSharing: zod.z.object({
+		enabled: zod.z.boolean().optional().default(false),
+		allowSiblingSharing: zod.z.boolean().optional().default(false),
+		maxFiles: zod.z.number().int().min(1).max(1e3).optional().default(100),
+		/** Aggregate disk budget for private output versions retained during a run. */
+		maxPrivateBytes: zod.z.number().int().min(1).max(10737418240).optional().default(268435456),
+		ttlMs: zod.z.number().int().min(1).max(864e5).optional().default(36e5)
+	}).optional(),
+	/** Maximum concurrent Code API uploads per route and authenticated principal. */
+	codeApiUploadConcurrency: zod.z.number().int().min(1).max(100).optional().default(3),
+	/** Maximum wall-clock time spent waiting on Code API rate limits per operation. */
+	codeApiMaxRetryWaitMs: zod.z.number().int().min(0).max(3e5).optional().default(2e4),
 	allowedProviders: zod.z.array(zod.z.union([zod.z.string(), eModelEndpointSchema])).optional(),
 	capabilities: zod.z.array(zod.z.nativeEnum(AgentCapabilities)).optional().default(defaultAgentCapabilities),
+	/** Controls which workspace-sharing scopes users may select for stateful code sessions.
+	*  Omit this block to preserve the legacy behavior of allowing every scope. */
+	statefulCodeSessions: zod.z.object({
+		allowedEnvironments: zod.z.array(zod.z.enum(STATEFUL_CODE_ENVIRONMENTS)).min(1),
+		/** Server-only personal worker enrollment policy. Effective principal
+		* policy may tighten, but never raise, the deployment ceiling. */
+		principalWorkers: zod.z.object({
+			enabled: zod.z.boolean().optional(),
+			/** Defaults to five. Zero disables enrollment; existing machines remain usable. */
+			maxPerUser: zod.z.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
+		}).optional(),
+		/** Operator-managed execution environments. Attached entries route to a
+		* Code API deployment backed by an outbound librechat-code worker. */
+		environments: zod.z.array(zod.z.object({
+			id: zod.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+			name: zod.z.string().min(1).max(100),
+			type: zod.z.enum(["managed", "attached"]),
+			baseURL: codeEnvironmentBaseURLSchema,
+			default: zod.z.boolean().optional(),
+			/** Server-only outbound worker route. Removed from public config. */
+			workerId: zod.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/).optional(),
+			/** Distinguishes operator policy from a principal-authorized
+			* environment merged into request-scoped server config. */
+			owner: zod.z.enum(["deployment", "principal"]).optional().default("deployment"),
+			/** Administrator-controlled user-tunable settings. Only fields
+			* represented here may be changed by a principal. */
+			configSchema: codeEnvironmentUserConfigSchema.optional(),
+			/** Request-scoped effective settings for a principal-owned environment.
+			* Deployment config should define defaults through configSchema instead. */
+			settings: codeEnvironmentUserSettingsSchema.optional(),
+			/** Server-only enrollment metadata. `tokenEnv` names an
+			* environment variable and never contains the token itself. */
+			pairing: zod.z.object({
+				workerId: zod.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/).optional(),
+				allowPrincipalWorkers: zod.z.boolean().optional().default(false),
+				tokenEnv: zod.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/)
+			}).superRefine((pairing, pairingContext) => {
+				if (pairing.workerId != null || pairing.allowPrincipalWorkers === true) return;
+				pairingContext.addIssue({
+					code: zod.z.ZodIssueCode.custom,
+					message: "Pairing requires a workerId or principal workers"
+				});
+			}).optional()
+		})).optional()
+	}).superRefine((value, context) => {
+		if (!value?.environments) return;
+		const ids = /* @__PURE__ */ new Set();
+		let defaults = 0;
+		let executableEnvironments = 0;
+		for (const environment of value.environments) {
+			const pairingOnly = environment.pairing?.allowPrincipalWorkers === true && environment.pairing.workerId == null && environment.workerId == null;
+			if (environment.pairing != null && environment.type !== "attached") context.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message: "Only attached code environments may configure pairing",
+				path: [
+					"environments",
+					environment.id,
+					"pairing"
+				]
+			});
+			if (environment.pairing != null && environment.owner !== "deployment") context.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message: "Only deployment-owned code environments may configure pairing",
+				path: [
+					"environments",
+					environment.id,
+					"pairing"
+				]
+			});
+			if (environment.pairing != null && !isSecureCodeEnvironmentControlURL(environment.baseURL)) context.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message: "Paired code environments require HTTPS outside loopback development",
+				path: [
+					"environments",
+					environment.id,
+					"baseURL"
+				]
+			});
+			if (environment.workerId != null && environment.pairing?.workerId != null && environment.workerId !== environment.pairing.workerId) context.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message: "Code environment workerId must match pairing.workerId",
+				path: [
+					"environments",
+					environment.id,
+					"workerId"
+				]
+			});
+			if (pairingOnly && environment.default === true) context.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message: "Pairing-only code control planes cannot be execution defaults",
+				path: [
+					"environments",
+					environment.id,
+					"default"
+				]
+			});
+			if (ids.has(environment.id)) context.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message: `Duplicate code environment id: ${environment.id}`,
+				path: ["environments"]
+			});
+			ids.add(environment.id);
+			if (!pairingOnly) {
+				executableEnvironments += 1;
+				if (environment.default === true) defaults += 1;
+			}
+		}
+		if (executableEnvironments > 0 && defaults !== 1) context.addIssue({
+			code: zod.z.ZodIssueCode.custom,
+			message: "Exactly one stateful code environment must be the default",
+			path: ["environments"]
+		});
+	}).optional(),
+	/** Optional trusted origin for in-process agent event delivery. */
+	eventDriven: zod.z.object({ selfUrl: zod.z.string().url().optional() }).optional(),
+	/** Conversational background-task delivery policy. Automatic completion wakeups are
+	* enabled unless an administrator explicitly restores poll-only behavior. */
+	backgroundTasks: zod.z.object({
+		completionWakeups: zod.z.boolean().optional().default(true),
+		/** Cooperative cancellation for process-local ordinary tools. Off
+		* by default so existing deployments opt into the new control. */
+		ordinaryToolCancellation: zod.z.boolean().optional().default(false)
+	}).optional(),
 	skills: zod.z.object({ maxCatalogSkills: zod.z.number().int().min(1).max(100).optional() }).optional(),
+	managementApi: managementApiSchema.optional(),
 	remoteApi: remoteApiSchema.optional(),
 	/** Human-in-the-loop tool approval policy. Off by default. */
 	toolApproval: toolApprovalPolicySchema,
@@ -4068,7 +5153,8 @@ const agentsEndpointSchema = baseEndpointSchema.omit({ baseURL: true }).merge(zo
 	capabilities: defaultAgentCapabilities,
 	maxCitations: 30,
 	maxCitationsPerFile: 7,
-	minRelevanceScore: .45
+	minRelevanceScore: .45,
+	maxSubagents: 10
 });
 const paramDefinitionSchema = zod.z.object({
 	key: zod.z.string(),
@@ -4086,7 +5172,11 @@ const paramDefinitionSchema = zod.z.object({
 	range: zod.z.object({
 		min: zod.z.number(),
 		max: zod.z.number(),
-		step: zod.z.number().optional()
+		step: zod.z.number().optional(),
+		positiveMin: zod.z.number().optional()
+	}).refine((value) => value.positiveMin == null || value.positiveMin <= value.max, {
+		message: "range.positiveMin cannot exceed range.max",
+		path: ["positiveMin"]
 	}).optional(),
 	enumMappings: zod.z.record(zod.z.union([
 		zod.z.number(),
@@ -4197,7 +5287,15 @@ const azureEndpointSchema = zod.z.object({
 		activityPhaseModel: true,
 		activityPhaseEndpoint: true,
 		activityPhasePrompt: true,
-		activityPhaseMaxPerRun: true
+		activityPhaseMaxPerRun: true,
+		reasoningLabel: true,
+		reasoningLabelModel: true,
+		reasoningLabelEndpoint: true,
+		reasoningLabelPrompt: true,
+		reasoningLabelMinChars: true,
+		reasoningLabelUpdateChars: true,
+		reasoningLabelUpdateIntervalMs: true,
+		reasoningLabelMaxPerRun: true
 	}).partial()
 );
 /**
@@ -4301,6 +5399,21 @@ const sttSchema = zod.z.object({
 	openai: sttOpenaiSchema.optional(),
 	azureOpenAI: sttAzureOpenAISchema.optional()
 });
+/**
+* The speech providers a schema actually configures. `allowedAddresses` is transport
+* policy rather than a provider, and a provider key present but empty configures
+* nothing. The speech services accept a schema only when exactly one survives here, so
+* the upload router reads availability from the same list and never routes audio to a
+* transcription that cannot run.
+*/
+function listConfiguredSpeechProviders(schema) {
+	if (schema == null) return [];
+	return Object.entries(schema).filter(([key, value]) => key !== "allowedAddresses" && value != null && typeof value === "object" && Object.keys(value).length > 0);
+}
+/** Whether a speech schema names exactly one usable provider. */
+function isSpeechProviderConfigured(schema) {
+	return listConfiguredSpeechProviders(schema).length === 1;
+}
 const speechTab = zod.z.object({
 	conversationMode: zod.z.boolean().optional(),
 	advancedMode: zod.z.boolean().optional(),
@@ -4342,6 +5455,10 @@ let RateLimitPrefix = /* @__PURE__ */ function(RateLimitPrefix) {
 	return RateLimitPrefix;
 }({});
 const rateLimitSchema = zod.z.object({
+	agentEvents: zod.z.object({
+		userMax: zod.z.number().int().positive().optional(),
+		userWindowInMinutes: zod.z.number().positive().optional()
+	}).optional(),
 	fileUploads: zod.z.object({
 		ipMax: zod.z.number().optional(),
 		ipWindowInMinutes: zod.z.number().optional(),
@@ -4381,7 +5498,14 @@ const termsOfServiceSchema = zod.z.object({
 	modalContent: zod.z.string().or(zod.z.array(zod.z.string())).optional()
 });
 const localizedStringSchema = zod.z.union([zod.z.string(), zod.z.record(zod.z.string())]);
+const mcpRefreshDefaults = {
+	toolsRefreshInterval: 300 * 1e3,
+	statusRefreshInterval: 30 * 1e3
+};
 const mcpServersSchema = zod.z.object({
+	/** Foreground polling intervals in milliseconds; 0 disables polling. */
+	toolsRefreshInterval: zod.z.number().int().nonnegative().max(2147483647).optional(),
+	statusRefreshInterval: zod.z.number().int().nonnegative().max(2147483647).optional(),
 	placeholder: zod.z.string().optional(),
 	use: zod.z.boolean().optional(),
 	create: zod.z.boolean().optional(),
@@ -4393,6 +5517,68 @@ const mcpServersSchema = zod.z.object({
 		subLabel: localizedStringSchema.optional()
 	}).optional()
 }).optional();
+/** Values the trace viewer uses for any `interface.traceViewer` field left unset. */
+const traceViewerDefaults = {
+	enabled: false,
+	showInputOutput: false,
+	maxRecords: 1e3,
+	maxContentLength: 5e4,
+	requestsPerMinute: 30,
+	requestTimeoutMs: 1e4
+};
+/** Inclusive bounds for the numeric `interface.traceViewer` fields. */
+const traceViewerLimits = {
+	maxRecords: {
+		min: 1,
+		max: 1e4
+	},
+	maxContentLength: {
+		min: 1,
+		max: 1e6
+	},
+	requestsPerMinute: {
+		min: 1,
+		max: 1e3
+	},
+	requestTimeoutMs: {
+		min: 1e3,
+		max: 3e5
+	}
+};
+const boundedIntegerSchema = (field) => zod.z.number().int().min(traceViewerLimits[field].min).max(traceViewerLimits[field].max).optional();
+const traceViewerSchema = zod.z.object({
+	/** Shows the conversation trace control for traces this deployment exported. */
+	enabled: zod.z.boolean().optional(),
+	/** Returns observation input, output and metadata in the record inspector. */
+	showInputOutput: zod.z.boolean().optional(),
+	/** Observations read from the tracing backend per request. */
+	maxRecords: boundedIntegerSchema("maxRecords"),
+	/** Characters kept from each input, output and metadata value before truncation. */
+	maxContentLength: boundedIntegerSchema("maxContentLength"),
+	/** Trace reads one user may start per minute. */
+	requestsPerMinute: boundedIntegerSchema("requestsPerMinute"),
+	/** Budget for each round trip to the tracing backend, in milliseconds. */
+	requestTimeoutMs: boundedIntegerSchema("requestTimeoutMs")
+});
+function boundedInteger(value, field) {
+	const { min, max } = traceViewerLimits[field];
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= min ? Math.min(value, max) : traceViewerDefaults[field];
+}
+/**
+* Fills unset or invalid `interface.traceViewer` fields from
+* {@link traceViewerDefaults}. Admin config overrides reach runtime without
+* schema validation, so every consumer reads the section through this.
+*/
+function resolveTraceViewerConfig(config) {
+	return {
+		enabled: config?.enabled === true,
+		showInputOutput: config?.showInputOutput === true,
+		maxRecords: boundedInteger(config?.maxRecords, "maxRecords"),
+		maxContentLength: boundedInteger(config?.maxContentLength, "maxContentLength"),
+		requestsPerMinute: boundedInteger(config?.requestsPerMinute, "requestsPerMinute"),
+		requestTimeoutMs: boundedInteger(config?.requestTimeoutMs, "requestTimeoutMs")
+	};
+}
 let RetentionMode = /* @__PURE__ */ function(RetentionMode) {
 	RetentionMode["ALL"] = "all";
 	RetentionMode["TEMPORARY"] = "temporary";
@@ -4426,6 +5612,7 @@ const interfaceSchema = zod.z.object({
 	})]).optional(),
 	temporaryChat: zod.z.boolean().optional(),
 	temporaryChatRetention: zod.z.number().min(1).max(8760).optional(),
+	generalChatRetention: zod.z.number().min(1).max(8760).optional(),
 	autoSubmitFromUrl: zod.z.boolean().optional(),
 	retentionMode: zod.z.nativeEnum(RetentionMode).default("temporary"),
 	retainAgentFiles: zod.z.boolean().optional(),
@@ -4433,6 +5620,7 @@ const interfaceSchema = zod.z.object({
 	webSearch: zod.z.boolean().optional(),
 	contextUsage: zod.z.boolean().optional(),
 	contextCost: zod.z.boolean().optional(),
+	feedback: zod.z.boolean().optional(),
 	currency: zod.z.object({
 		code: zod.z.string(),
 		rate: zod.z.number().positive()
@@ -4445,6 +5633,7 @@ const interfaceSchema = zod.z.object({
 	marketplace: zod.z.object({ use: zod.z.boolean().optional() }).optional(),
 	fileSearch: zod.z.boolean().optional(),
 	fileCitations: zod.z.boolean().optional(),
+	traceViewer: traceViewerSchema.optional(),
 	/** Tool keys (and `'mcp'` or an MCP server name) pinned to the prompt bar by default */
 	defaultPinnedTools: zod.z.array(zod.z.string()).optional(),
 	buildInfo: zod.z.boolean().optional(),
@@ -4466,6 +5655,26 @@ const interfaceSchema = zod.z.object({
 		share: zod.z.boolean().optional(),
 		public: zod.z.boolean().optional(),
 		snapshotFiles: zod.z.boolean().optional()
+	})]).optional(),
+	schedules: zod.z.union([zod.z.boolean(), zod.z.object({
+		use: zod.z.boolean().optional(),
+		create: zod.z.boolean().optional(),
+		maxPerUser: zod.z.number().int().min(0).optional(),
+		minIntervalMinutes: zod.z.number().int().min(1).optional(),
+		autoDisableAfterFailures: zod.z.number().int().min(1).optional(),
+		admissionConcurrency: zod.z.number().int().min(1).max(100).optional(),
+		fireConcurrency: zod.z.number().int().min(1).optional(),
+		mcpPreflightConcurrency: zod.z.number().int().min(1).max(10).optional(),
+		mcpPreflightTimeoutMs: zod.z.number().int().min(1e3).max(6e5).optional(),
+		/** Refuse schedules that are not filed under a chat project. Enforced on
+		*  create/update AND at every fire, so raising it later stops schedules
+		*  that predate the policy instead of grandfathering them. */
+		requireProject: zod.z.boolean().optional(),
+		/** Pins every scheduled run to ONE chat project, ignoring any client
+		*  choice. Implies `requireProject`. The project must belong to the
+		*  schedule's owner, so a deployment-wide value only makes sense with a
+		*  per-user/per-role config override. */
+		projectId: zod.z.string().trim().min(1).optional()
 	})]).optional()
 }).default({
 	modelSelect: true,
@@ -4492,6 +5701,7 @@ const interfaceSchema = zod.z.object({
 	webSearch: true,
 	contextUsage: true,
 	contextCost: false,
+	feedback: true,
 	peoplePicker: {
 		users: true,
 		groups: true,
@@ -4561,12 +5771,14 @@ let SearchProviders = /* @__PURE__ */ function(SearchProviders) {
 	SearchProviders["SERPER"] = "serper";
 	SearchProviders["SEARXNG"] = "searxng";
 	SearchProviders["TAVILY"] = "tavily";
+	SearchProviders["KEENABLE"] = "keenable";
 	return SearchProviders;
 }({});
 let ScraperProviders = /* @__PURE__ */ function(ScraperProviders) {
 	ScraperProviders["FIRECRAWL"] = "firecrawl";
 	ScraperProviders["SERPER"] = "serper";
 	ScraperProviders["TAVILY"] = "tavily";
+	ScraperProviders["KEENABLE"] = "keenable";
 	return ScraperProviders;
 }({});
 let RerankerTypes = /* @__PURE__ */ function(RerankerTypes) {
@@ -4581,6 +5793,17 @@ let SafeSearchTypes = /* @__PURE__ */ function(SafeSearchTypes) {
 	SafeSearchTypes[SafeSearchTypes["STRICT"] = 2] = "STRICT";
 	return SafeSearchTypes;
 }({});
+/**
+* Normalizes a SearXNG engine list into the comma-separated form the API expects.
+* Accepts the YAML list or comma-separated string an operator may write, and is
+* applied both at the schema boundary and when loading the runtime config, since
+* `loadCustomConfig` returns the raw YAML object rather than the parsed result.
+*/
+function normalizeSearxngEngines(engines) {
+	if (engines == null) return;
+	const normalized = (Array.isArray(engines) ? engines : engines.split(",")).map((engine) => engine.trim()).filter(Boolean);
+	return normalized.length ? normalized.join(",") : void 0;
+}
 const webSearchSchema = zod.z.object({
 	allowedAddresses: allowedAddressesSchema,
 	serperApiKey: zod.z.string().optional().default("${SERPER_API_KEY}"),
@@ -4596,6 +5819,8 @@ const webSearchSchema = zod.z.object({
 	tavilyApiKeyPreview: apiKeyPreviewSchema,
 	tavilySearchUrl: zod.z.string().optional().default("${TAVILY_SEARCH_URL}"),
 	tavilyExtractUrl: zod.z.string().optional().default("${TAVILY_EXTRACT_URL}"),
+	keenableApiKey: zod.z.string().optional().default("${KEENABLE_API_KEY}"),
+	keenableApiUrl: zod.z.string().optional().default("${KEENABLE_API_URL}"),
 	jinaApiKey: zod.z.string().optional().default("${JINA_API_KEY}"),
 	jinaApiKeyPreview: apiKeyPreviewSchema,
 	jinaApiUrl: zod.z.string().optional().default("${JINA_API_URL}"),
@@ -4633,6 +5858,16 @@ const webSearchSchema = zod.z.object({
 			tag: zod.z.string().nullable().optional()
 		}).optional()
 	}).optional(),
+	searxngSearchOptions: zod.z.object({
+		engines: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).transform(normalizeSearxngEngines).optional(),
+		language: zod.z.string().optional(),
+		timeRange: zod.z.enum([
+			"day",
+			"month",
+			"year"
+		]).optional(),
+		timeout: zod.z.number().int().positive().max(12e4).optional()
+	}).optional(),
 	tavilySearchOptions: zod.z.object({
 		searchDepth: zod.z.enum([
 			"basic",
@@ -4673,6 +5908,16 @@ const webSearchSchema = zod.z.object({
 		includeFavicon: zod.z.boolean().optional(),
 		format: zod.z.enum(["markdown", "text"]).optional(),
 		timeout: zod.z.number().int().nonnegative().max(12e4).optional()
+	}).optional(),
+	keenableSearchOptions: zod.z.object({
+		maxResults: zod.z.number().int().min(1).max(20).optional(),
+		site: zod.z.string().optional(),
+		attributionTitle: zod.z.string().optional(),
+		timeout: zod.z.number().int().nonnegative().max(12e4).optional()
+	}).optional(),
+	keenableScraperOptions: zod.z.object({
+		attributionTitle: zod.z.string().optional(),
+		timeout: zod.z.number().int().nonnegative().max(12e4).optional()
 	}).optional()
 });
 const ocrSchema = zod.z.object({
@@ -4760,13 +6005,6 @@ const summarizationConfigSchema = zod.z.object({
 	retainRecent: retainRecentConfigSchema.optional()
 });
 const customEndpointsSchema = zod.z.array(endpointSchema.partial()).optional();
-/**
-* Validates a messageFilter PII regex at config load. Defaults to native RegExp so browser
-* builds add no extra engine; the server injects a check backed by the linear-time runtime
-* engine (RE2) via setMessageFilterRegexValidator, so a pattern the runtime cannot compile
-* (backreferences, lookaround, control escapes, and so on) is rejected at load rather than
-* silently dropped at request time.
-*/
 let messageFilterRegexValidator = (value) => {
 	try {
 		new RegExp(value, "g");
@@ -4779,28 +6017,134 @@ const setMessageFilterRegexValidator = (validate) => {
 	messageFilterRegexValidator = validate;
 };
 const messageFilterPiiCustomPatternSchema = zod.z.object({
-	id: zod.z.string().min(1),
-	label: zod.z.string().min(1),
-	regex: zod.z.string().min(1).refine((value) => messageFilterRegexValidator(value), { message: "Unsupported regex: not compatible with the RE2 engine (no backreferences, lookaround, or control escapes)" })
+	id: zod.z.string().min(1).max(256),
+	label: zod.z.string().min(1).max(512),
+	regex: zod.z.string().min(1).max(512)
 });
 const messageFilterPiiSchema = zod.z.object({
-	starterPatterns: zod.z.array(zod.z.string()).optional(),
-	customPatterns: zod.z.array(messageFilterPiiCustomPatternSchema).optional()
+	starterPatterns: zod.z.array(zod.z.string().max(256)).max(256).optional(),
+	customPatterns: zod.z.array(messageFilterPiiCustomPatternSchema).max(256).optional()
+}).superRefine((pii, context) => {
+	let regexCharacters = 0;
+	let regexInstructions = 0;
+	for (let index = 0; index < (pii.customPatterns?.length ?? 0); index++) {
+		const pattern = pii.customPatterns?.[index];
+		if (pattern == null) continue;
+		regexCharacters += pattern.regex.length;
+		const result = messageFilterRegexValidator(pattern.regex);
+		if (!(typeof result === "boolean" ? result : result.supported)) {
+			context.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				path: [
+					"customPatterns",
+					index,
+					"regex"
+				],
+				message: "Unsupported regex: not compatible with the RE2 engine (no backreferences, lookaround, or control escapes)"
+			});
+			continue;
+		}
+		if (typeof result !== "boolean" && result.programSize != null) regexInstructions += result.programSize;
+	}
+	if (regexCharacters > 8192) context.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		path: ["customPatterns"],
+		message: `Custom PII regexes may contain at most ${MAX_PII_CUSTOM_REGEX_CHARACTERS} characters in total`
+	});
+	if (regexInstructions > 8192) context.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		path: ["customPatterns"],
+		message: `Custom PII regexes may compile to at most ${MAX_PII_CUSTOM_REGEX_INSTRUCTIONS} instructions in total`
+	});
 });
 const messageFilterSchema = zod.z.object({ pii: messageFilterPiiSchema.optional() });
-const langfuseConfigSchema = zod.z.object({
-	enabled: zod.z.boolean().optional(),
-	publicKey: zod.z.string().optional(),
-	secretKey: zod.z.string().optional(),
-	/** Stable Langfuse project identity returned when credentials are verified. */
-	projectId: zod.z.string().optional(),
-	/** Masked preview of the secret key, stored at write time so
-	* admin reads can show which secret key is configured without returning the secret. */
-	secretKeyPreview: zod.z.string().optional(),
-	/** Routing key for one of the deployment-configured tenant Langfuse destinations. */
-	destination: zod.z.string().optional()
-});
-const configSchema = zod.z.object({
+/** User fields a deployment may select as the Langfuse trace `userId`. */
+const LANGFUSE_TRACE_USER_ID_FIELDS = [
+	"id",
+	"email",
+	"username",
+	"name",
+	"openidId",
+	"samlId",
+	"ldapId",
+	"googleId",
+	"githubId",
+	"discordId",
+	"appleId",
+	"facebookId"
+];
+/** User fields a deployment may copy into Langfuse trace metadata. */
+const LANGFUSE_TRACE_USER_METADATA_FIELDS = [
+	...LANGFUSE_TRACE_USER_ID_FIELDS,
+	"role",
+	"provider"
+];
+/** Request fields a deployment may copy into Langfuse trace metadata. */
+const LANGFUSE_TRACE_CONVERSATION_METADATA_FIELDS = [
+	"conversationId",
+	"endpoint",
+	"endpointType",
+	"provider",
+	"model",
+	"modelLabel",
+	"spec"
+];
+/**
+* What a deployment attaches to every Langfuse trace beyond the defaults.
+* Nothing here is exported unless explicitly listed, so the default trace
+* carries only the internal user id and no user or request metadata.
+*/
+const langfuseTraceConfigSchema = zod.z.object({
+	/**
+	* Which user field becomes the trace `userId`. Defaults to the internal user
+	* id; a user with no value for the chosen field keeps the internal id.
+	*/
+	userIdField: zod.z.enum(LANGFUSE_TRACE_USER_ID_FIELDS).optional(),
+	/** User fields exported as `librechat.user.<field>` trace metadata. */
+	userMetadataFields: zod.z.array(zod.z.enum(LANGFUSE_TRACE_USER_METADATA_FIELDS)).optional(),
+	/**
+	* Request fields exported as trace metadata: `librechat.conversation.id`,
+	* `librechat.endpoint`, `librechat.endpoint.type`, `librechat.provider`,
+	* `librechat.model`, `librechat.model.label`, and `librechat.spec`.
+	*/
+	conversationMetadataFields: zod.z.array(zod.z.enum(LANGFUSE_TRACE_CONVERSATION_METADATA_FIELDS)).optional()
+});
+const langfuseConfigSchema = zod.z.object({
+	enabled: zod.z.boolean().optional(),
+	publicKey: zod.z.string().optional(),
+	secretKey: zod.z.string().optional(),
+	/** Stable Langfuse project identity returned when credentials are verified. */
+	projectId: zod.z.string().optional(),
+	/** Masked preview of the secret key, stored at write time so
+	* admin reads can show which secret key is configured without returning the secret. */
+	secretKeyPreview: zod.z.string().optional(),
+	/** Routing key for one of the deployment-configured tenant Langfuse destinations. */
+	destination: zod.z.string().optional(),
+	/**
+	* Custom request headers sent on every outbound Langfuse request — trace and
+	* media export, feedback scores, and credential verification — for
+	* self-hosted instances behind an authenticating proxy or gateway. Values
+	* support `${ENV_VAR}` interpolation.
+	*
+	* Deployment-level only. Trace export batches spans from every user through
+	* one exporter, so unlike endpoint headers these cannot carry per-user
+	* placeholders. Headers referencing an unset variable, naming an
+	* infrastructure secret, or carrying an invalid HTTP field name are dropped
+	* with a warning rather than sent.
+	*
+	* Sent only when the deployment configures exactly one Langfuse origin, and
+	* only to that origin. The map cannot say which endpoint it authenticates
+	* to, so with several configured origins any choice of recipient would risk
+	* disclosing a gateway credential to the others; a warning is logged instead.
+	* Multi-destination deployments need per-destination headers, which this
+	* schema does not yet express — and note the fanout collector forwards only
+	* `Authorization` upstream regardless.
+	*/
+	headers: zod.z.record(zod.z.string()).optional(),
+	/** Trace user identity and allowlisted user/request metadata. */
+	trace: langfuseTraceConfigSchema.optional()
+});
+const configSchema = zod.z.object({
 	version: zod.z.string(),
 	cache: zod.z.boolean().default(true),
 	ocr: ocrSchema.optional(),
@@ -4816,7 +6160,35 @@ const configSchema = zod.z.object({
 	mcpServers: MCPServersSchema.optional(),
 	mcpSettings: zod.z.object({
 		allowedDomains: zod.z.array(zod.z.string()).optional(),
-		allowedAddresses: allowedAddressesSchema
+		allowedAddresses: allowedAddressesSchema,
+		catalogRecovery: zod.z.object({
+			discoveryBackoffMs: zod.z.array(zod.z.number().int().positive().max(1440 * 6e4)).min(1).max(8).default([
+				5 * 6e4,
+				10 * 6e4,
+				20 * 6e4,
+				30 * 6e4
+			]),
+			discoveryTimeoutMs: zod.z.number().int().positive().max(5 * 6e4).default(3e3),
+			/** How long past `discoveryTimeoutMs` a stalled discovery may hold its catalog slot and
+			* coalesced requests. It is never cancelled, so OAuth tokens it redeemed still persist,
+			* and no other discovery for the same server state starts until it settles. */
+			discoverySettleGraceMs: zod.z.number().int().nonnegative().max(5 * 6e4).default(1e4),
+			reauthRetryMs: zod.z.number().int().positive().max(1440 * 6e4).default(30 * 6e4),
+			maxStateEntries: zod.z.number().int().positive().max(1e6).default(1e4),
+			/** Process-wide: how many discoveries released past `discoverySettleGraceMs` may still be
+			* running before recovery starts no new discovery until one settles. The default matches
+			* the three catalog slots a stalled dependency could hold before discoveries were released. */
+			maxDetachedDiscoveries: zod.z.number().int().positive().max(1e3).default(3),
+			generationReadTimeoutMs: zod.z.number().int().positive().max(1e4).default(500),
+			authorizationFenceRetryMs: zod.z.array(zod.z.number().int().nonnegative().max(6e4)).min(1).max(8).default([
+				0,
+				50,
+				200
+			]),
+			authorizationFenceTimeoutMs: zod.z.number().int().positive().max(3e4).default(1e3),
+			authorizationFenceRetryIntervalMs: zod.z.number().int().positive().max(60 * 6e4).default(3e4),
+			authorizationFenceRetryBatchSize: zod.z.number().int().positive().max(1e4).default(100)
+		}).default({})
 	}).optional(),
 	interface: interfaceSchema,
 	turnstile: turnstileSchema.optional(),
@@ -4841,6 +6213,7 @@ const configSchema = zod.z.object({
 	rateLimits: rateLimitSchema.optional(),
 	fileConfig: fileConfigSchema.optional(),
 	modelSpecs: specsConfigSchema.optional(),
+	filters: filtersConfigSchema.optional(),
 	messageFilter: messageFilterSchema.optional(),
 	endpoints: zod.z.object({
 		allowedAddresses: allowedAddressesSchema,
@@ -4874,6 +6247,7 @@ let KnownEndpoints = /* @__PURE__ */ function(KnownEndpoints) {
 	KnownEndpoints["groq"] = "groq";
 	KnownEndpoints["helicone"] = "helicone";
 	KnownEndpoints["huggingface"] = "huggingface";
+	KnownEndpoints["lemonade"] = "lemonade";
 	KnownEndpoints["mistral"] = "mistral";
 	KnownEndpoints["mlx"] = "mlx";
 	KnownEndpoints["ollama"] = "ollama";
@@ -4912,6 +6286,7 @@ const alternateName = {
 	["anthropic"]: "Anthropic",
 	["custom"]: "Custom",
 	["bedrock"]: "AWS Bedrock",
+	["lemonade"]: "AMD Lemonade",
 	["ollama"]: "Ollama",
 	["deepseek"]: "DeepSeek",
 	["moonshot"]: "Moonshot",
@@ -4919,6 +6294,14 @@ const alternateName = {
 	["vercel"]: "Vercel",
 	["helicone"]: "Helicone"
 };
+/**
+* Models the Assistants endpoints cannot run. GPT-6 Astra serves tool calls only
+* from the Responses API, and the Assistants surface does not route through
+* `getOpenAILLMConfig`, so listing it there would offer a configuration the
+* provider rejects. Kept out of `sharedOpenAIModels`, which both Assistants
+* catalogs consume.
+*/
+const responsesOnlyOpenAIModels = ["gpt-6-astra"];
 const sharedOpenAIModels = [
 	"gpt-5.6",
 	"gpt-5.6-terra",
@@ -4946,6 +6329,7 @@ const sharedOpenAIModels = [
 	"gpt-4o"
 ];
 const sharedAnthropicModels = [
+	"claude-fable-5-1",
 	"claude-fable-5",
 	"claude-opus-5",
 	"claude-opus-4-8",
@@ -4980,6 +6364,7 @@ const sharedAnthropicModels = [
 * availability); Opus 4.1 has no global profile, so it uses `us.`.
 */
 const bedrockModels = [
+	"global.anthropic.claude-fable-5-1",
 	"global.anthropic.claude-fable-5",
 	"global.anthropic.claude-opus-5",
 	"global.anthropic.claude-opus-4-8",
@@ -5012,8 +6397,9 @@ const bedrockModels = [
 const defaultModels = {
 	["azureAssistants"]: sharedOpenAIModels,
 	["assistants"]: [...sharedOpenAIModels, "chatgpt-4o-latest"],
-	["agents"]: sharedOpenAIModels,
+	["agents"]: [...responsesOnlyOpenAIModels, ...sharedOpenAIModels],
 	["google"]: [
+		"gemini-3.8-flash",
 		"gemini-3.7-flash",
 		"gemini-3.6-flash",
 		"gemini-3.5-flash",
@@ -5029,6 +6415,7 @@ const defaultModels = {
 	],
 	["anthropic"]: sharedAnthropicModels,
 	["openAI"]: [
+		...responsesOnlyOpenAIModels,
 		...sharedOpenAIModels,
 		"chatgpt-4o-latest",
 		"gpt-4-vision-preview",
@@ -5041,12 +6428,19 @@ const fitlerAssistantModels = (str) => {
 	return /gpt-4|gpt-3\\.5/i.test(str) && !/vision|instruct/i.test(str);
 };
 const openAIModels = defaultModels["openAI"];
+/**
+* The OpenAI catalog without the models only the first-party OpenAI endpoint
+* can run. Azure OpenAI shares this list, but Astra is neither routed to the
+* Responses API nor given its request constraints there, and listing it first
+* would let it become the default selection.
+*/
+const nonResponsesOnlyOpenAIModels = openAIModels.filter((model) => !responsesOnlyOpenAIModels.includes(model));
 const initialModelsConfig = {
 	initial: [],
 	["openAI"]: openAIModels,
 	["assistants"]: openAIModels.filter(fitlerAssistantModels),
 	["agents"]: openAIModels,
-	["azureOpenAI"]: openAIModels,
+	["azureOpenAI"]: nonResponsesOnlyOpenAIModels,
 	["google"]: defaultModels["google"],
 	["anthropic"]: defaultModels["anthropic"],
 	["bedrock"]: defaultModels["bedrock"]
@@ -5181,6 +6575,10 @@ let CacheKeys = /* @__PURE__ */ function(CacheKeys) {
 	*/
 	CacheKeys["USER_PRINCIPALS"] = "USER_PRINCIPALS";
 	/**
+	* Key for cached prompt group access ID sets (accessible, public, owned).
+	*/
+	CacheKeys["PROMPT_GROUPS_ACCESS"] = "PROMPT_GROUPS_ACCESS";
+	/**
 	* Key for per-conversation stateful code sandbox prewarm/warm state.
 	*/
 	CacheKeys["SANDBOX_PREWARM"] = "SANDBOX_PREWARM";
@@ -5340,6 +6738,10 @@ let ViolationTypes = /* @__PURE__ */ function(ViolationTypes) {
 	* Registration violations.
 	*/
 	ViolationTypes["REGISTRATIONS"] = "registrations";
+	/**
+	* Shared link retrieval limit violations.
+	*/
+	ViolationTypes["SHARE_LIMIT"] = "share_limit";
 	return ViolationTypes;
 }({});
 /**
@@ -5403,6 +6805,14 @@ let ErrorTypes = /* @__PURE__ */ function(ErrorTypes) {
 	*/
 	ErrorTypes["RESOURCE_RECOVERY_REQUIRED"] = "resource_recovery_required";
 	/**
+	* Agent selected a stateful Code API workspace scope disabled by the deployment.
+	*/
+	ErrorTypes["STATEFUL_CODE_ENVIRONMENT_NOT_ALLOWED"] = "stateful_code_environment_not_allowed";
+	/**
+	* A conversation's selected attached workspace cannot be used as requested.
+	*/
+	ErrorTypes["CODE_WORKSPACE_UNAVAILABLE"] = "code_workspace_unavailable";
+	/**
 	* Invalid Agent Provider (excluded by Admin)
 	*/
 	ErrorTypes["INVALID_AGENT_PROVIDER"] = "invalid_agent_provider";
@@ -5423,6 +6833,14 @@ let ErrorTypes = /* @__PURE__ */ function(ErrorTypes) {
 	*/
 	ErrorTypes["AUTH_FAILED"] = "auth_failed";
 	/**
+	* Authentication rejected by a rate limiter
+	*/
+	ErrorTypes["AUTH_RATE_LIMITED"] = "auth_rate_limited";
+	/**
+	* Authentication rejected because the account or IP is banned
+	*/
+	ErrorTypes["AUTH_BANNED"] = "auth_banned";
+	/**
 	* Model refused to respond (content policy violation)
 	*/
 	ErrorTypes["REFUSAL"] = "refusal";
@@ -5430,6 +6848,34 @@ let ErrorTypes = /* @__PURE__ */ function(ErrorTypes) {
 	* SSE stream 404 — job completed, expired, or was deleted before the subscriber connected
 	*/
 	ErrorTypes["STREAM_EXPIRED"] = "stream_expired";
+	/**
+	* Provider does not serve the requested model
+	*/
+	ErrorTypes["MODEL_NOT_FOUND"] = "model_not_found";
+	/**
+	* Provider throttled or refused the request for exceeding a rate/spend allowance
+	*/
+	ErrorTypes["MODEL_RATE_LIMIT"] = "model_rate_limit";
+	/**
+	* An agent model provider failed and the run could not recover.
+	*/
+	ErrorTypes["UPSTREAM_MODEL_ERROR"] = "upstream_model_error";
+	/**
+	* Context pruning removed every message; nothing fits the configured context window
+	*/
+	ErrorTypes["EMPTY_MESSAGES"] = "empty_messages";
+	/**
+	* Formatted provider payload exceeded the context budget before invocation
+	*/
+	ErrorTypes["FINAL_CONTEXT_OVERFLOW"] = "final_context_overflow";
+	/**
+	* A manual compaction the graph could not attempt; `reason` says why
+	*/
+	ErrorTypes["COMPACTION_SKIPPED"] = "compaction_skipped";
+	/**
+	* A manual compaction whose summarizer produced nothing; history is untouched
+	*/
+	ErrorTypes["COMPACTION_FAILED"] = "compaction_failed";
 	return ErrorTypes;
 }({});
 /**
@@ -5561,7 +7007,7 @@ let TTSProviders = /* @__PURE__ */ function(TTSProviders) {
 /** Enum for app-wide constants */
 let Constants = /* @__PURE__ */ function(Constants) {
 	/**
-	* Key for the app's version. The placeholder `v0.8.8-rc1` is
+	* Key for the app's version. The placeholder `v0.8.8-rc3` is
 	* swapped in by `@rollup/plugin-replace` during `npm run build:data-provider`
 	* using the value of the root `package.json`'s `version` field. Consumers
 	* always import this via the built dist bundle (see `main` field in
@@ -5569,9 +7015,9 @@ let Constants = /* @__PURE__ */ function(Constants) {
 	* substituted value. Only tests that import the TypeScript source directly
 	* would observe the raw placeholder.
 	*/
-	Constants["VERSION"] = "v0.8.8-rc1";
+	Constants["VERSION"] = "v0.8.8-rc3";
 	/** Key for the Custom Config's version (librechat.yaml). */
-	Constants["CONFIG_VERSION"] = "1.3.14";
+	Constants["CONFIG_VERSION"] = "1.3.16";
 	/** Standard value for the first message's `parentMessageId` value, to indicate no parent exists. */
 	Constants["NO_PARENT"] = "00000000-0000-0000-0000-000000000000";
 	/** Standard value to use whatever the submission prelim. `responseMessageId` is */
@@ -5625,6 +7071,15 @@ let Constants = /* @__PURE__ */ function(Constants) {
 	Constants["SUBAGENT"] = "subagent";
 	/** Poll tool for retrieving the status/result of a backgrounded tool call. */
 	Constants["CHECK_BACKGROUND_TASK"] = "check_background_task";
+	/**
+	* `finish_reason` stamped on an assistant message whose turn ended because the
+	* agent exhausted its per-turn graph step budget (`recursionLimit`) rather than
+	* because the model chose to stop. Distinct from a user abort: nothing failed and
+	* nothing was cancelled, the turn simply ran out of room. The UI keys its
+	* "tool call limit reached" notice off this value. The hover Continue control
+	* is withheld for this reason because the notice already offers the way forward.
+	*/
+	Constants["TOOL_CALL_LIMIT_FINISH_REASON"] = "tool_call_limit";
 	return Constants;
 }({});
 /**
@@ -5711,6 +7166,95 @@ function normalizeMCPToolKey(toolKey, rawServerNames) {
 	if (normalized === matched) return toolKey;
 	return `${toolKey.slice(0, toolKey.length - matched.length)}${normalized}`;
 }
+/**
+* Strips a redundant leading server-name prefix from a raw upstream tool name
+* before it is embedded into a model-facing key, so the key doesn't carry the
+* server twice (`acme_trace_..._mcp_acme`) and push long tool names
+* past provider function-name limits (64 chars). The match is case-insensitive
+* because display-cased server names ("Acme") conventionally prefix their
+* tools in lowercase. Ingestion that strips must record the original name
+* (`serverToolName` on the cached definition) — tool calls send THAT name back
+* to the server, never the stripped one. Catalog producers must not call this
+* directly: only {@link stripServerNamePrefixes} sees the whole sibling set and
+* can keep colliding results apart.
+*/
+function stripServerNamePrefix(toolName, normalizedServerName) {
+	const prefixLength = normalizedServerName.length + 1;
+	if (toolName.length <= prefixLength) return toolName;
+	if (toolName.slice(0, prefixLength).toLowerCase() !== `${normalizedServerName.toLowerCase()}_`) return toolName;
+	const stripped = toolName.slice(prefixLength);
+	if (isReservedMCPToolName(stripped)) return toolName;
+	/** `isActionTool` classifies keys by the RELATIVE position of `_action_`
+	*  and `_mcp_`; stripping moves the first `_mcp_` earlier, so a server
+	*  whose normalized name contains `_action_` could see a real MCP tool
+	*  reclassified as an OpenAPI action (bypassing MCP authorization). Never
+	*  produce a key whose classification differs from the raw key's. */
+	const keySuffix = `_mcp_${normalizedServerName}`;
+	if (isActionTool(`${stripped}${keySuffix}`) !== isActionTool(`${toolName}${keySuffix}`)) return toolName;
+	return stripped;
+}
+/**
+* Synthetic markers consumed by prefix (`isMCPAllPlaceholder`, the server-pin
+* skip, the client's OAuth stream classification), so each reserves BOTH its
+* exact name and its `${marker}${mcp_delimiter}` namespace: a stripped
+* remainder inside any of them would turn a real upstream tool into the
+* server-wide wildcard, the UI pin placeholder, or a synthetic OAuth call.
+*/
+const RESERVED_MCP_TOOL_MARKERS = [
+	`sys__all__sys`,
+	`sys__server__sys`,
+	"oauth"
+];
+function isReservedMCPToolName(toolName) {
+	/** `mcp_` opens the server-scoped pluginKey namespace (`mcp_${serverName}`),
+	*  and `lc_transfer_to_` opens the agent-handoff namespace (the client
+	*  renders such calls as handoffs; the background and intent passes exclude
+	*  them) — pre-strip tool keys could never enter either, since they always
+	*  began with the server name itself. */
+	if (toolName.startsWith(`mcp_`) || toolName.startsWith(`lc_transfer_to_`)) return true;
+	return RESERVED_MCP_TOOL_MARKERS.some((marker) => toolName === marker || toolName.startsWith(`${marker}_mcp_`));
+}
+/**
+* Maps every raw tool name in a server's catalog to its model-facing name,
+* stripping redundant server-name prefixes collision-free: when two names
+* yield the same result — a bare `foo` next to `<server>_foo`, or the
+* case-variant pair `<server>_Foo` / `<Server>_Foo` under the case-insensitive
+* prefix match — every collider keeps its raw name, so two distinct upstream
+* tools can never collapse onto one key. Unprefixed names count against the
+* result set through their identity mapping, which is what makes the bare-name
+* case fall out of the same counter.
+*/
+function stripServerNamePrefixes(toolNames, normalizedServerName) {
+	const rawNames = new Set(toolNames);
+	const finalNames = new Map(toolNames.map((name) => {
+		const stripped = stripServerNamePrefix(name, normalizedServerName);
+		/** Every sibling's RAW name is reserved even when that sibling itself
+		*  strips away: keys persisted BEFORE stripping embed raw names, so a
+		*  stripped result landing on another sibling's raw name would route
+		*  that sibling's legacy references to the wrong upstream tool. */
+		return [name, stripped !== name && rawNames.has(stripped) ? name : stripped];
+	}));
+	/** Reverting a collider to its raw name can itself collide with ANOTHER
+	*  sibling's stripped result (`foo` / `acme_foo` / `acme_acme_foo`), so the
+	*  guard iterates to a fixpoint. Each pass converts at least one stripped
+	*  result back to its unique raw name, so it terminates within the catalog
+	*  size. */
+	let changed = true;
+	while (changed) {
+		changed = false;
+		const counts = /* @__PURE__ */ new Map();
+		finalNames.forEach((result) => {
+			counts.set(result, (counts.get(result) ?? 0) + 1);
+		});
+		finalNames.forEach((result, raw) => {
+			if (result !== raw && (counts.get(result) ?? 0) > 1) {
+				finalNames.set(raw, raw);
+				changed = true;
+			}
+		});
+	}
+	return finalNames;
+}
 function splitMCPToolKey(toolKey, knownServerNames) {
 	if (knownServerNames?.length) {
 		let matched;
@@ -5930,6 +7474,7 @@ let PrincipalModel = /* @__PURE__ */ function(PrincipalModel) {
 */
 let ResourceType = /* @__PURE__ */ function(ResourceType) {
 	ResourceType["AGENT"] = "agent";
+	ResourceType["CODE_ENVIRONMENT"] = "codeEnvironment";
 	ResourceType["PROMPTGROUP"] = "promptGroup";
 	ResourceType["MCPSERVER"] = "mcpServer";
 	ResourceType["REMOTE_AGENT"] = "remoteAgent";
@@ -5949,6 +7494,8 @@ let PermissionBits = /* @__PURE__ */ function(PermissionBits) {
 	PermissionBits[PermissionBits["DELETE"] = 4] = "DELETE";
 	/**  1000 - Can share agent with others (future) */
 	PermissionBits[PermissionBits["SHARE"] = 8] = "SHARE";
+	/** 10000 - Can view Insights data for an agent when VIEW is also present */
+	PermissionBits[PermissionBits["VIEW_INSIGHTS"] = 16] = "VIEW_INSIGHTS";
 	return PermissionBits;
 }({});
 /**
@@ -5958,6 +7505,9 @@ let AccessRoleIds = /* @__PURE__ */ function(AccessRoleIds) {
 	AccessRoleIds["AGENT_VIEWER"] = "agent_viewer";
 	AccessRoleIds["AGENT_EDITOR"] = "agent_editor";
 	AccessRoleIds["AGENT_OWNER"] = "agent_owner";
+	AccessRoleIds["CODE_ENVIRONMENT_VIEWER"] = "codeEnvironment_viewer";
+	AccessRoleIds["CODE_ENVIRONMENT_EDITOR"] = "codeEnvironment_editor";
+	AccessRoleIds["CODE_ENVIRONMENT_OWNER"] = "codeEnvironment_owner";
 	AccessRoleIds["PROMPTGROUP_VIEWER"] = "promptGroup_viewer";
 	AccessRoleIds["PROMPTGROUP_EDITOR"] = "promptGroup_editor";
 	AccessRoleIds["PROMPTGROUP_OWNER"] = "promptGroup_owner";
@@ -5987,6 +7537,8 @@ const principalSchema = zod.z.object({
 	description: zod.z.string().optional(),
 	idOnTheSource: zod.z.string().optional(),
 	accessRoleId: zod.z.nativeEnum(AccessRoleIds).optional(),
+	viewInsights: zod.z.boolean().optional(),
+	isAdmin: zod.z.boolean().optional(),
 	memberCount: zod.z.number().optional()
 });
 /**
@@ -6074,17 +7626,20 @@ function permBitsToAccessLevel(permBits) {
 function accessRoleToPermBits(accessRoleId) {
 	switch (accessRoleId) {
 		case "agent_viewer":
+		case "codeEnvironment_viewer":
 		case "promptGroup_viewer":
 		case "mcpServer_viewer":
 		case "remoteAgent_viewer":
 		case "skill_viewer":
 		case "sharedLink_viewer": return 1;
 		case "agent_editor":
+		case "codeEnvironment_editor":
 		case "promptGroup_editor":
 		case "mcpServer_editor":
 		case "remoteAgent_editor":
 		case "skill_editor": return 3;
 		case "agent_owner":
+		case "codeEnvironment_owner":
 		case "promptGroup_owner":
 		case "mcpServer_owner":
 		case "remoteAgent_owner":
@@ -6111,11 +7666,15 @@ let QueryKeys = /* @__PURE__ */ function(QueryKeys) {
 	QueryKeys["sharedLinks"] = "sharedLinks";
 	QueryKeys["allConversations"] = "allConversations";
 	QueryKeys["archivedConversations"] = "archivedConversations";
+	QueryKeys["pinnedConversations"] = "pinnedConversations";
 	QueryKeys["searchConversations"] = "searchConversations";
 	QueryKeys["conversation"] = "conversation";
 	QueryKeys["searchEnabled"] = "searchEnabled";
 	QueryKeys["langfuseConnection"] = "langfuseConnection";
 	QueryKeys["langfuseSessionLink"] = "langfuseSessionLink";
+	QueryKeys["conversationTraceAvailability"] = "conversationTraceAvailability";
+	QueryKeys["conversationTraceRecords"] = "conversationTraceRecords";
+	QueryKeys["conversationTraceRecord"] = "conversationTraceRecord";
 	QueryKeys["user"] = "user";
 	QueryKeys["name"] = "name";
 	QueryKeys["models"] = "models";
@@ -6127,6 +7686,8 @@ let QueryKeys = /* @__PURE__ */ function(QueryKeys) {
 	QueryKeys["tokenCount"] = "tokenCount";
 	QueryKeys["availablePlugins"] = "availablePlugins";
 	QueryKeys["startupConfig"] = "startupConfig";
+	QueryKeys["insights"] = "insights";
+	QueryKeys["insightsAccess"] = "insightsAccess";
 	QueryKeys["assistants"] = "assistants";
 	QueryKeys["assistant"] = "assistant";
 	QueryKeys["agents"] = "agents";
@@ -6184,10 +7745,32 @@ let QueryKeys = /* @__PURE__ */ function(QueryKeys) {
 	QueryKeys["toolFavorites"] = "toolFavorites";
 	QueryKeys["skillStates"] = "skillStates";
 	QueryKeys["favorites"] = "favorites";
+	QueryKeys["schedules"] = "schedules";
+	QueryKeys["schedule"] = "schedule";
+	QueryKeys["parentSubagents"] = "parentSubagents";
+	QueryKeys["subagentThread"] = "subagentThread";
+	QueryKeys["codeEnvironments"] = "codeEnvironments";
+	QueryKeys["agentQueuedTurns"] = "agentQueuedTurns";
+	QueryKeys["pinnedOrder"] = "pinnedOrder";
 	return QueryKeys;
 }({});
-const DynamicQueryKeys = { agentFiles: (agentId) => ["agentFiles", agentId] };
+const DynamicQueryKeys = {
+	agentFiles: (agentId) => ["agentFiles", agentId],
+	codeEnvironmentStatus: (id) => [
+		"codeEnvironments",
+		id,
+		"status"
+	]
+};
 let MutationKeys = /* @__PURE__ */ function(MutationKeys) {
+	MutationKeys["subagentControl"] = "subagentControl";
+	MutationKeys["enqueueAgentQueuedTurn"] = "enqueueAgentQueuedTurn";
+	MutationKeys["cancelAgentQueuedTurn"] = "cancelAgentQueuedTurn";
+	/** Whole-array favorites write, keyed so every hook instance's write is
+	*  visible to the others through the query client. */
+	MutationKeys["updateFavorites"] = "updateFavorites";
+	/** Pinned-section display order write, keyed for the same reason. */
+	MutationKeys["updatePinnedOrder"] = "updatePinnedOrder";
 	MutationKeys["updateLangfuseConnection"] = "updateLangfuseConnection";
 	MutationKeys["testLangfuseConnection"] = "testLangfuseConnection";
 	MutationKeys["createAgentApiKey"] = "createAgentApiKey";
@@ -6211,6 +7794,7 @@ let MutationKeys = /* @__PURE__ */ function(MutationKeys) {
 	MutationKeys["deleteAgentAction"] = "deleteAgentAction";
 	MutationKeys["revertAgentVersion"] = "revertAgentVersion";
 	MutationKeys["deleteUser"] = "deleteUser";
+	MutationKeys["updateUserPreferences"] = "updateUserPreferences";
 	MutationKeys["updateRole"] = "updateRole";
 	MutationKeys["enableTwoFactor"] = "enableTwoFactor";
 	MutationKeys["verifyTwoFactor"] = "verifyTwoFactor";
@@ -6224,6 +7808,14 @@ let MutationKeys = /* @__PURE__ */ function(MutationKeys) {
 	MutationKeys["deleteSkillNode"] = "deleteSkillNode";
 	MutationKeys["updateSkillNodeContent"] = "updateSkillNodeContent";
 	MutationKeys["convoPin"] = "convoPin";
+	MutationKeys["archiveAllConversations"] = "archiveAllConversations";
+	MutationKeys["createSchedule"] = "createSchedule";
+	MutationKeys["updateSchedule"] = "updateSchedule";
+	MutationKeys["deleteSchedule"] = "deleteSchedule";
+	MutationKeys["runSchedule"] = "runSchedule";
+	MutationKeys["pairCodeEnvironment"] = "pairCodeEnvironment";
+	MutationKeys["updateCodeEnvironmentSettings"] = "updateCodeEnvironmentSettings";
+	MutationKeys["deleteCodeEnvironment"] = "deleteCodeEnvironment";
 	return MutationKeys;
 }({});
 //#endregion
@@ -6625,15 +8217,18 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	addPromptToGroup: () => addPromptToGroup,
 	addTagToConversation: () => addTagToConversation,
 	addToolFavorite: () => addToolFavorite,
+	archiveAllConversations: () => archiveAllConversations,
 	archiveConversation: () => archiveConversation,
 	assignConversationToProject: () => assignConversationToProject,
 	bindActionOAuth: () => bindActionOAuth,
 	bindMCPOAuth: () => bindMCPOAuth,
 	branchMessage: () => branchMessage,
 	callTool: () => callTool,
+	cancelAgentQueuedTurn: () => cancelAgentQueuedTurn,
 	cancelMCPOAuth: () => cancelMCPOAuth,
 	clearAllConversations: () => clearAllConversations,
 	confirmTwoFactor: () => confirmTwoFactor,
+	controlSubagentTask: () => controlSubagentTask,
 	createAgent: () => createAgent,
 	createAgentApiKey: () => createAgentApiKey,
 	createAssistant: () => createAssistant,
@@ -6643,6 +8238,7 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	createPreset: () => createPreset,
 	createProject: () => createProject,
 	createPrompt: () => createPrompt,
+	createSchedule: () => createSchedule,
 	createSharedLink: () => createSharedLink,
 	createSkill: () => createSkill,
 	createSkillNode: () => createSkillNode,
@@ -6651,16 +8247,19 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	deleteAgentAction: () => deleteAgentAction,
 	deleteAgentApiKey: () => deleteAgentApiKey,
 	deleteAssistant: () => deleteAssistant,
+	deleteCodeEnvironment: () => deleteCodeEnvironment,
 	deleteConversation: () => deleteConversation,
 	deleteConversationTag: () => deleteConversationTag,
 	deleteFiles: () => deleteFiles,
 	deleteGitHubSkillSyncCredential: () => deleteGitHubSkillSyncCredential,
 	deleteMCPServer: () => deleteMCPServer,
 	deleteMemory: () => deleteMemory,
+	deleteMemoryById: () => deleteMemoryById,
 	deletePreset: () => deletePreset,
 	deleteProject: () => deleteProject,
 	deletePrompt: () => deletePrompt,
 	deletePromptGroup: () => deletePromptGroup,
+	deleteSchedule: () => deleteSchedule,
 	deleteSharedLink: () => deleteSharedLink,
 	deleteSkill: () => deleteSkill,
 	deleteSkillFile: () => deleteSkillFile,
@@ -6671,6 +8270,7 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	duplicateConversation: () => duplicateConversation,
 	editArtifact: () => editArtifact,
 	enableTwoFactor: () => enableTwoFactor,
+	enqueueAgentQueuedTurn: () => enqueueAgentQueuedTurn,
 	forkConversation: () => forkConversation,
 	forkSharedConversation: () => forkSharedConversation,
 	genTitle: () => genTitle,
@@ -6692,9 +8292,14 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	getAvailableTools: () => getAvailableTools,
 	getBanner: () => getBanner,
 	getCategories: () => getCategories,
+	getCodeEnvironmentStatus: () => getCodeEnvironmentStatus,
+	getCodeEnvironments: () => getCodeEnvironments,
 	getCodeOutputDownload: () => getCodeOutputDownload,
 	getConversationById: () => getConversationById,
 	getConversationTags: () => getConversationTags,
+	getConversationTraceAvailability: () => getConversationTraceAvailability,
+	getConversationTraceRecord: () => getConversationTraceRecord,
+	getConversationTraceRecords: () => getConversationTraceRecords,
 	getConversations: () => getConversations,
 	getCustomConfigSpeech: () => getCustomConfigSpeech,
 	getDomainServerBaseUrl: () => getDomainServerBaseUrl,
@@ -6708,6 +8313,8 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	getFiles: () => getFiles,
 	getGitHubSkillSyncStatus: () => getGitHubSkillSyncStatus,
 	getGraphApiToken: () => getGraphApiToken,
+	getInsights: () => getInsights,
+	getInsightsAccess: () => getInsightsAccess,
 	getLangfuseConnection: () => getLangfuseConnection,
 	getLangfuseSessionLink: () => getLangfuseSessionLink,
 	getLoginGoogle: () => getLoginGoogle,
@@ -6720,8 +8327,11 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	getMCPTools: () => getMCPTools,
 	getMarketplaceAgents: () => getMarketplaceAgents,
 	getMemories: () => getMemories,
+	getMessageById: () => getMessageById,
 	getMessagesByConvoId: () => getMessagesByConvoId,
 	getModels: () => getModels,
+	getParentSubagents: () => getParentSubagents,
+	getPinnedOrder: () => getPinnedOrder,
 	getPresets: () => getPresets,
 	getProjectById: () => getProjectById,
 	getPrompt: () => getPrompt,
@@ -6731,6 +8341,8 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	getRandomPrompts: () => getRandomPrompts,
 	getResourcePermissions: () => getResourcePermissions,
 	getRole: () => getRole,
+	getSchedule: () => getSchedule,
+	getSchedules: () => getSchedules,
 	getSearchEnabled: () => getSearchEnabled,
 	getSharedFileDownload: () => getSharedFileDownload,
 	getSharedFilePreview: () => getSharedFilePreview,
@@ -6743,6 +8355,7 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	getSkillStates: () => getSkillStates,
 	getSkillTree: () => getSkillTree,
 	getStartupConfig: () => getStartupConfig,
+	getSubagentThread: () => getSubagentThread,
 	getTokenConfig: () => getTokenConfig,
 	getToolCalls: () => getToolCalls,
 	getToolFavorites: () => getToolFavorites,
@@ -6754,6 +8367,7 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	healthCheck: () => healthCheck,
 	importConversationsFile: () => importConversationsFile,
 	importSkill: () => importSkill,
+	listAgentQueuedTurns: () => listAgentQueuedTurns,
 	listAgents: () => listAgents,
 	listAssistants: () => listAssistants,
 	listConversations: () => listConversations,
@@ -6767,6 +8381,7 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	logout: () => logout,
 	makePromptProduction: () => makePromptProduction,
 	markFilesUsage: () => markFilesUsage,
+	pairCodeEnvironment: () => pairCodeEnvironment,
 	pinConversation: () => pinConversation,
 	rebuildConversationTags: () => rebuildConversationTags,
 	recordPromptGroupUsage: () => recordPromptGroupUsage,
@@ -6781,6 +8396,7 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	revokeAllUserKeys: () => revokeAllUserKeys,
 	revokeUserKey: () => revokeUserKey,
 	runGitHubSkillSync: () => runGitHubSkillSync,
+	runScheduleNow: () => runScheduleNow,
 	searchPrincipals: () => searchPrincipals,
 	setGitHubSkillSyncCredential: () => setGitHubSkillSyncCredential,
 	speechToText: () => speechToText,
@@ -6791,6 +8407,7 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	updateAgentAction: () => updateAgentAction,
 	updateAgentPermissions: () => updateAgentPermissions,
 	updateAssistant: () => updateAssistant,
+	updateCodeEnvironmentSettings: () => updateCodeEnvironmentSettings,
 	updateConversation: () => updateConversation,
 	updateConversationTag: () => updateConversationTag,
 	updateFavorites: () => updateFavorites,
@@ -6800,11 +8417,13 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	updateMCPServersPermissions: () => updateMCPServersPermissions,
 	updateMarketplacePermissions: () => updateMarketplacePermissions,
 	updateMemory: () => updateMemory,
+	updateMemoryById: () => updateMemoryById,
 	updateMemoryPermissions: () => updateMemoryPermissions,
 	updateMemoryPreferences: () => updateMemoryPreferences,
 	updateMessage: () => updateMessage,
 	updateMessageContent: () => updateMessageContent,
 	updatePeoplePickerPermissions: () => updatePeoplePickerPermissions,
+	updatePinnedOrder: () => updatePinnedOrder,
 	updatePreset: () => updatePreset,
 	updateProject: () => updateProject,
 	updatePromptGroup: () => updatePromptGroup,
@@ -6812,6 +8431,7 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	updatePromptPermissions: () => updatePromptPermissions,
 	updateRemoteAgentsPermissions: () => updateRemoteAgentsPermissions,
 	updateResourcePermissions: () => updateResourcePermissions,
+	updateSchedule: () => updateSchedule,
 	updateSharedLink: () => updateSharedLink,
 	updateSkill: () => updateSkill,
 	updateSkillNode: () => updateSkillNode,
@@ -6821,6 +8441,7 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	updateTokenCount: () => updateTokenCount,
 	updateUserKey: () => updateUserKey,
 	updateUserPlugins: () => updateUserPlugins,
+	updateUserPreferences: () => updateUserPreferences,
 	uploadAgentAvatar: () => uploadAgentAvatar,
 	uploadAssistantAvatar: () => uploadAssistantAvatar,
 	uploadAvatar: () => uploadAvatar,
@@ -6832,6 +8453,25 @@ var data_service_exports = /* @__PURE__ */ __exportAll({
 	verifyTwoFactor: () => verifyTwoFactor,
 	verifyTwoFactorTemp: () => verifyTwoFactorTemp
 });
+function getInsights(params = {}) {
+	const query = new URLSearchParams();
+	for (const [key, value] of Object.entries(params)) if (Array.isArray(value)) value.forEach((item) => query.append(key, String(item)));
+	else if (value !== void 0 && value !== null && value !== "") query.set(key, String(value));
+	const suffix = query.toString() ? `?${query.toString()}` : "";
+	return request_default.get(`${insights()}${suffix}`);
+}
+function getInsightsAccess() {
+	return request_default.get(insightsAccess());
+}
+function getConversationTraceAvailability(conversationId) {
+	return request_default.get(conversationTraceAvailability(conversationId));
+}
+function getConversationTraceRecords({ conversationId, cursor }, signal) {
+	return request_default.get(conversationTraceRecords(conversationId, cursor), signal ? { signal } : void 0);
+}
+function getConversationTraceRecord({ conversationId, recordId, messageId, sourceId }, signal) {
+	return request_default.get(conversationTraceRecord(conversationId, recordId, messageId, sourceId), signal ? { signal } : void 0);
+}
 function getLangfuseConnection() {
 	return request_default.get(adminLangfuseConnection());
 }
@@ -6853,12 +8493,34 @@ function revokeAllUserKeys() {
 function deleteUser(payload) {
 	return request_default.deleteWithOptions(deleteUser$1(), { data: payload });
 }
+function getCodeEnvironments() {
+	return request_default.get(codeEnvironments());
+}
+function getCodeEnvironmentStatus(id) {
+	return request_default.get(codeEnvironmentStatus(id));
+}
+function pairCodeEnvironment(payload) {
+	return request_default.post(codeEnvironmentPairings(), payload);
+}
+function deleteCodeEnvironment(id) {
+	return request_default.delete(codeEnvironmentById(id));
+}
+function updateCodeEnvironmentSettings({ id, settings }) {
+	return request_default.patch(codeEnvironmentSettings(id), { settings });
+}
 function getFavorites() {
 	return request_default.get(`${apiBaseUrl()}/api/user/settings/favorites`);
 }
 function updateFavorites(favorites) {
 	return request_default.post(`${apiBaseUrl()}/api/user/settings/favorites`, { favorites });
 }
+/** Combined Pinned-section display order: favorite and pinned-chat entry keys interleaved. */
+function getPinnedOrder() {
+	return request_default.get(pinnedOrder());
+}
+function updatePinnedOrder(pinnedOrder$1) {
+	return request_default.post(pinnedOrder(), { pinnedOrder: pinnedOrder$1 });
+}
 /** Tool favorites — starred marketplace items (builtins, tools, MCP servers, skills). */
 function getToolFavorites() {
 	return request_default.get(toolFavorites());
@@ -6936,6 +8598,9 @@ function getSearchEnabled() {
 function getUser() {
 	return request_default.get(user());
 }
+function updateUserPreferences(preferences) {
+	return request_default.patch(userPreferences(), preferences);
+}
 function getUserBalance() {
 	return request_default.get(balance());
 }
@@ -7314,6 +8979,9 @@ function updateConversation(payload) {
 function archiveConversation(payload) {
 	return request_default.post(archiveConversation$1(), { arg: payload });
 }
+function archiveAllConversations() {
+	return request_default.post(archiveAllConversations$1(), {});
+}
 function listProjects(params) {
 	return request_default.get(projects(params ?? {}));
 }
@@ -7372,6 +9040,21 @@ function getMessagesByConvoId(conversationId) {
 	if (conversationId === "new" || conversationId === "PENDING") return Promise.resolve([]);
 	return request_default.get(messages({ conversationId }));
 }
+function getMessageById(conversationId, messageId) {
+	return request_default.get(messages({
+		conversationId,
+		messageId
+	}));
+}
+function getParentSubagents(parentConversationId) {
+	return request_default.get(parentSubagents(parentConversationId));
+}
+function getSubagentThread(parentConversationId, threadId, taskId, cursor) {
+	return request_default.get(subagentThread(parentConversationId, threadId, taskId, cursor));
+}
+function controlSubagentTask(parentConversationId, threadId, body) {
+	return request_default.post(subagentControl(parentConversationId, threadId), body);
+}
 function getPrompt(id) {
 	return request_default.get(getPrompt$1(id));
 }
@@ -7420,6 +9103,33 @@ function getRandomPrompts(variables) {
 function listSkills(params) {
 	return request_default.get(listSkillsWithFilters(params ?? {}));
 }
+function getSchedules() {
+	return request_default.get(schedules());
+}
+function enqueueAgentQueuedTurn(payload) {
+	return request_default.post(agentQueuedTurns(), payload);
+}
+function listAgentQueuedTurns(conversationId, clientRequestIds) {
+	return request_default.get(agentQueuedTurnsByConversation(conversationId, clientRequestIds));
+}
+function cancelAgentQueuedTurn(queuedTurnId) {
+	return request_default.delete(agentQueuedTurn(queuedTurnId));
+}
+function getSchedule(id) {
+	return request_default.get(schedule(id));
+}
+function createSchedule(payload) {
+	return request_default.post(schedules(), payload);
+}
+function updateSchedule(id, payload) {
+	return request_default.patch(schedule(id), payload);
+}
+function deleteSchedule(id) {
+	return request_default.delete(schedule(id));
+}
+function runScheduleNow(id) {
+	return request_default.post(runSchedule(id), {});
+}
 function getSkill(id) {
 	return request_default.get(getSkill$1(id));
 }
@@ -7610,12 +9320,21 @@ const getMemories = () => {
 const deleteMemory = (key, agentId) => {
 	return request_default.delete(memory(key, agentId));
 };
+const deleteMemoryById = (id, agentId) => {
+	return request_default.delete(memoryById(id, agentId));
+};
 const updateMemory = (key, value, originalKey, agentId) => {
 	return request_default.patch(memory(originalKey || key, agentId), {
 		key,
 		value
 	});
 };
+const updateMemoryById = (id, value, key, agentId) => {
+	return request_default.patch(memoryById(id, agentId), {
+		value,
+		...key ? { key } : {}
+	});
+};
 const updateMemoryPreferences = (preferences) => {
 	return request_default.patch(memoryPreferences(), preferences);
 };
@@ -7650,6 +9369,18 @@ const getActiveJobs = () => {
 	return request_default.get(activeJobs());
 };
 //#endregion
+Object.defineProperty(exports, "ACTION_METADATA_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return ACTION_METADATA_FILTER_FIELDS;
+	}
+});
+Object.defineProperty(exports, "AGENT_INSTRUCTION_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return AGENT_INSTRUCTION_FILTER_FIELDS;
+	}
+});
 Object.defineProperty(exports, "AUTH_USER_DOC_BY_ID_PREFIX", {
 	enumerable: true,
 	get: function() {
@@ -7734,6 +9465,72 @@ Object.defineProperty(exports, "BedrockReasoningConfig", {
 		return BedrockReasoningConfig;
 	}
 });
+Object.defineProperty(exports, "CODE_APPROVAL_MODES", {
+	enumerable: true,
+	get: function() {
+		return CODE_APPROVAL_MODES;
+	}
+});
+Object.defineProperty(exports, "CODE_ENVIRONMENT_COMMAND_TIMEOUT_DEFAULT_MS", {
+	enumerable: true,
+	get: function() {
+		return CODE_ENVIRONMENT_COMMAND_TIMEOUT_DEFAULT_MS;
+	}
+});
+Object.defineProperty(exports, "CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS", {
+	enumerable: true,
+	get: function() {
+		return CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS;
+	}
+});
+Object.defineProperty(exports, "CODE_ENVIRONMENT_DECISION_VERSION", {
+	enumerable: true,
+	get: function() {
+		return CODE_ENVIRONMENT_DECISION_VERSION;
+	}
+});
+Object.defineProperty(exports, "CODE_ENVIRONMENT_MODES", {
+	enumerable: true,
+	get: function() {
+		return CODE_ENVIRONMENT_MODES;
+	}
+});
+Object.defineProperty(exports, "CODE_WORKSPACE_ID_PATTERN", {
+	enumerable: true,
+	get: function() {
+		return CODE_WORKSPACE_ID_PATTERN;
+	}
+});
+Object.defineProperty(exports, "CODE_WORKSPACE_MAX_COUNT", {
+	enumerable: true,
+	get: function() {
+		return CODE_WORKSPACE_MAX_COUNT;
+	}
+});
+Object.defineProperty(exports, "CODE_WORKSPACE_OPERATIONS", {
+	enumerable: true,
+	get: function() {
+		return CODE_WORKSPACE_OPERATIONS;
+	}
+});
+Object.defineProperty(exports, "CODE_WORKSPACE_SELECTION_ERROR_REASONS", {
+	enumerable: true,
+	get: function() {
+		return CODE_WORKSPACE_SELECTION_ERROR_REASONS;
+	}
+});
+Object.defineProperty(exports, "CONVERSATION_STARTER_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return CONVERSATION_STARTER_FILTER_FIELDS;
+	}
+});
+Object.defineProperty(exports, "CONVERSATION_TITLE_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return CONVERSATION_TITLE_FILTER_FIELDS;
+	}
+});
 Object.defineProperty(exports, "CacheKeys", {
 	enumerable: true,
 	get: function() {
@@ -7746,6 +9543,12 @@ Object.defineProperty(exports, "Capabilities", {
 		return Capabilities;
 	}
 });
+Object.defineProperty(exports, "CodeApprovalModeError", {
+	enumerable: true,
+	get: function() {
+		return CodeApprovalModeError;
+	}
+});
 Object.defineProperty(exports, "CohereConstants", {
 	enumerable: true,
 	get: function() {
@@ -7770,6 +9573,12 @@ Object.defineProperty(exports, "DEFAULT_MEMORY_MAX_INPUT_TOKENS", {
 		return DEFAULT_MEMORY_MAX_INPUT_TOKENS;
 	}
 });
+Object.defineProperty(exports, "DefaultLLMDeliveryPath", {
+	enumerable: true,
+	get: function() {
+		return DefaultLLMDeliveryPath;
+	}
+});
 Object.defineProperty(exports, "DynamicQueryKeys", {
 	enumerable: true,
 	get: function() {
@@ -7806,6 +9615,12 @@ Object.defineProperty(exports, "ErrorTypes", {
 		return ErrorTypes;
 	}
 });
+Object.defineProperty(exports, "FEEDBACK_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return FEEDBACK_FILTER_FIELDS;
+	}
+});
 Object.defineProperty(exports, "FEEDBACK_RATINGS", {
 	enumerable: true,
 	get: function() {
@@ -7824,6 +9639,18 @@ Object.defineProperty(exports, "FEEDBACK_TAGS", {
 		return FEEDBACK_TAGS;
 	}
 });
+Object.defineProperty(exports, "FILE_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return FILE_FILTER_FIELDS;
+	}
+});
+Object.defineProperty(exports, "FILTER_PII_STARTER_PATTERNS", {
+	enumerable: true,
+	get: function() {
+		return FILTER_PII_STARTER_PATTERNS;
+	}
+});
 Object.defineProperty(exports, "FetchTokenConfig", {
 	enumerable: true,
 	get: function() {
@@ -7854,6 +9681,12 @@ Object.defineProperty(exports, "ForkOptions", {
 		return ForkOptions;
 	}
 });
+Object.defineProperty(exports, "HITL_MESSAGE_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return HITL_MESSAGE_FILTER_FIELDS;
+	}
+});
 Object.defineProperty(exports, "ImageDetail", {
 	enumerable: true,
 	get: function() {
@@ -7884,154 +9717,280 @@ Object.defineProperty(exports, "KnownEndpoints", {
 		return KnownEndpoints;
 	}
 });
-Object.defineProperty(exports, "LocalStorageKeys", {
+Object.defineProperty(exports, "LANGFUSE_TRACE_CONVERSATION_METADATA_FIELDS", {
 	enumerable: true,
 	get: function() {
-		return LocalStorageKeys;
+		return LANGFUSE_TRACE_CONVERSATION_METADATA_FIELDS;
 	}
 });
-Object.defineProperty(exports, "MAX_SUBAGENTS", {
+Object.defineProperty(exports, "LANGFUSE_TRACE_USER_ID_FIELDS", {
 	enumerable: true,
 	get: function() {
-		return MAX_SUBAGENTS;
+		return LANGFUSE_TRACE_USER_ID_FIELDS;
 	}
 });
-Object.defineProperty(exports, "MAX_SUBAGENT_DEPTH", {
+Object.defineProperty(exports, "LANGFUSE_TRACE_USER_METADATA_FIELDS", {
 	enumerable: true,
 	get: function() {
-		return MAX_SUBAGENT_DEPTH;
+		return LANGFUSE_TRACE_USER_METADATA_FIELDS;
 	}
 });
-Object.defineProperty(exports, "MAX_SUBAGENT_GRAPH_NODES", {
+Object.defineProperty(exports, "LocalStorageKeys", {
 	enumerable: true,
 	get: function() {
-		return MAX_SUBAGENT_GRAPH_NODES;
+		return LocalStorageKeys;
 	}
 });
-Object.defineProperty(exports, "MAX_SUBAGENT_RUN_CONFIGS", {
+Object.defineProperty(exports, "MAX_CHAT_PROJECT_DESCRIPTION_LENGTH", {
 	enumerable: true,
 	get: function() {
-		return MAX_SUBAGENT_RUN_CONFIGS;
+		return MAX_CHAT_PROJECT_DESCRIPTION_LENGTH;
 	}
 });
-Object.defineProperty(exports, "MCPOptionsSchema", {
+Object.defineProperty(exports, "MAX_CHAT_PROJECT_NAME_LENGTH", {
 	enumerable: true,
 	get: function() {
-		return MCPOptionsSchema;
+		return MAX_CHAT_PROJECT_NAME_LENGTH;
 	}
 });
-Object.defineProperty(exports, "MCPServerUserInputSchema", {
+Object.defineProperty(exports, "MAX_GRAPH_SUBAGENT_MEMBERS", {
 	enumerable: true,
 	get: function() {
-		return MCPServerUserInputSchema;
+		return MAX_GRAPH_SUBAGENT_MEMBERS;
 	}
 });
-Object.defineProperty(exports, "MCPServersSchema", {
+Object.defineProperty(exports, "MAX_MCP_ICON_PATH_LENGTH", {
 	enumerable: true,
 	get: function() {
-		return MCPServersSchema;
+		return MAX_MCP_ICON_PATH_LENGTH;
 	}
 });
-Object.defineProperty(exports, "MCP_USER_INPUT_FIELDS", {
+Object.defineProperty(exports, "MAX_PII_CUSTOM_PATTERNS_TOTAL", {
 	enumerable: true,
 	get: function() {
-		return MCP_USER_INPUT_FIELDS;
+		return MAX_PII_CUSTOM_PATTERNS_TOTAL;
 	}
 });
-Object.defineProperty(exports, "MYTHOS_CLASS_FAMILIES", {
+Object.defineProperty(exports, "MAX_PII_CUSTOM_REGEX_CHARACTERS", {
 	enumerable: true,
 	get: function() {
-		return MYTHOS_CLASS_FAMILIES;
+		return MAX_PII_CUSTOM_REGEX_CHARACTERS;
 	}
 });
-Object.defineProperty(exports, "MemoryScope", {
+Object.defineProperty(exports, "MAX_PII_CUSTOM_REGEX_INSTRUCTIONS", {
 	enumerable: true,
 	get: function() {
-		return MemoryScope;
+		return MAX_PII_CUSTOM_REGEX_INSTRUCTIONS;
 	}
 });
-Object.defineProperty(exports, "MessageContentTypes", {
+Object.defineProperty(exports, "MAX_PII_PATTERNS_PER_SOURCE", {
 	enumerable: true,
 	get: function() {
-		return MessageContentTypes;
+		return MAX_PII_PATTERNS_PER_SOURCE;
 	}
 });
-Object.defineProperty(exports, "MutationKeys", {
+Object.defineProperty(exports, "MAX_PII_PATTERN_ID_LENGTH", {
 	enumerable: true,
 	get: function() {
-		return MutationKeys;
+		return MAX_PII_PATTERN_ID_LENGTH;
 	}
 });
-Object.defineProperty(exports, "OCRStrategy", {
+Object.defineProperty(exports, "MAX_PII_PATTERN_LABEL_LENGTH", {
 	enumerable: true,
 	get: function() {
-		return OCRStrategy;
+		return MAX_PII_PATTERN_LABEL_LENGTH;
 	}
 });
-Object.defineProperty(exports, "OptionTypes", {
+Object.defineProperty(exports, "MAX_PII_PATTERN_LENGTH", {
 	enumerable: true,
 	get: function() {
-		return OptionTypes;
+		return MAX_PII_PATTERN_LENGTH;
 	}
 });
-Object.defineProperty(exports, "PermissionBits", {
+Object.defineProperty(exports, "MAX_SUBAGENTS", {
 	enumerable: true,
 	get: function() {
-		return PermissionBits;
+		return MAX_SUBAGENTS;
 	}
 });
-Object.defineProperty(exports, "PrincipalModel", {
+Object.defineProperty(exports, "MAX_SUBAGENTS_CEILING", {
 	enumerable: true,
 	get: function() {
-		return PrincipalModel;
+		return MAX_SUBAGENTS_CEILING;
 	}
 });
-Object.defineProperty(exports, "PrincipalType", {
+Object.defineProperty(exports, "MAX_SUBAGENT_DEPTH", {
 	enumerable: true,
 	get: function() {
-		return PrincipalType;
+		return MAX_SUBAGENT_DEPTH;
 	}
 });
-Object.defineProperty(exports, "Providers", {
+Object.defineProperty(exports, "MAX_SUBAGENT_GRAPH_NODES", {
 	enumerable: true,
 	get: function() {
-		return Providers;
+		return MAX_SUBAGENT_GRAPH_NODES;
 	}
 });
-Object.defineProperty(exports, "QueryKeys", {
+Object.defineProperty(exports, "MAX_SUBAGENT_RUN_CONFIGS", {
 	enumerable: true,
 	get: function() {
-		return QueryKeys;
+		return MAX_SUBAGENT_RUN_CONFIGS;
 	}
 });
-Object.defineProperty(exports, "REFILL_INTERVAL_UNITS", {
+Object.defineProperty(exports, "MCPOptionsSchema", {
 	enumerable: true,
 	get: function() {
-		return REFILL_INTERVAL_UNITS;
+		return MCPOptionsSchema;
 	}
 });
-Object.defineProperty(exports, "RateLimitPrefix", {
+Object.defineProperty(exports, "MCPServerUserInputSchema", {
 	enumerable: true,
 	get: function() {
-		return RateLimitPrefix;
+		return MCPServerUserInputSchema;
 	}
 });
-Object.defineProperty(exports, "ReasoningContext", {
+Object.defineProperty(exports, "MCPServersSchema", {
 	enumerable: true,
 	get: function() {
-		return ReasoningContext;
+		return MCPServersSchema;
 	}
 });
-Object.defineProperty(exports, "ReasoningEffort", {
+Object.defineProperty(exports, "MCP_SERVER_TITLE_ERROR", {
 	enumerable: true,
 	get: function() {
-		return ReasoningEffort;
+		return MCP_SERVER_TITLE_ERROR;
 	}
 });
-Object.defineProperty(exports, "ReasoningMode", {
+Object.defineProperty(exports, "MCP_SERVER_TITLE_PATTERN", {
 	enumerable: true,
 	get: function() {
-		return ReasoningMode;
+		return MCP_SERVER_TITLE_PATTERN;
+	}
+});
+Object.defineProperty(exports, "MCP_USER_INPUT_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return MCP_USER_INPUT_FIELDS;
+	}
+});
+Object.defineProperty(exports, "MEMORY_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return MEMORY_FILTER_FIELDS;
+	}
+});
+Object.defineProperty(exports, "MESSAGE_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return MESSAGE_FILTER_FIELDS;
+	}
+});
+Object.defineProperty(exports, "MODEL_PARAMETER_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return MODEL_PARAMETER_FILTER_FIELDS;
+	}
+});
+Object.defineProperty(exports, "MYTHOS_CLASS_FAMILIES", {
+	enumerable: true,
+	get: function() {
+		return MYTHOS_CLASS_FAMILIES;
+	}
+});
+Object.defineProperty(exports, "MemoryScope", {
+	enumerable: true,
+	get: function() {
+		return MemoryScope;
+	}
+});
+Object.defineProperty(exports, "MessageContentTypes", {
+	enumerable: true,
+	get: function() {
+		return MessageContentTypes;
+	}
+});
+Object.defineProperty(exports, "MutationKeys", {
+	enumerable: true,
+	get: function() {
+		return MutationKeys;
+	}
+});
+Object.defineProperty(exports, "OCRStrategy", {
+	enumerable: true,
+	get: function() {
+		return OCRStrategy;
+	}
+});
+Object.defineProperty(exports, "OptionTypes", {
+	enumerable: true,
+	get: function() {
+		return OptionTypes;
+	}
+});
+Object.defineProperty(exports, "PROMPT_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return PROMPT_FILTER_FIELDS;
+	}
+});
+Object.defineProperty(exports, "PermissionBits", {
+	enumerable: true,
+	get: function() {
+		return PermissionBits;
+	}
+});
+Object.defineProperty(exports, "PrincipalModel", {
+	enumerable: true,
+	get: function() {
+		return PrincipalModel;
+	}
+});
+Object.defineProperty(exports, "PrincipalType", {
+	enumerable: true,
+	get: function() {
+		return PrincipalType;
+	}
+});
+Object.defineProperty(exports, "Providers", {
+	enumerable: true,
+	get: function() {
+		return Providers;
+	}
+});
+Object.defineProperty(exports, "QueryKeys", {
+	enumerable: true,
+	get: function() {
+		return QueryKeys;
+	}
+});
+Object.defineProperty(exports, "REFILL_INTERVAL_UNITS", {
+	enumerable: true,
+	get: function() {
+		return REFILL_INTERVAL_UNITS;
+	}
+});
+Object.defineProperty(exports, "RateLimitPrefix", {
+	enumerable: true,
+	get: function() {
+		return RateLimitPrefix;
+	}
+});
+Object.defineProperty(exports, "ReasoningContext", {
+	enumerable: true,
+	get: function() {
+		return ReasoningContext;
+	}
+});
+Object.defineProperty(exports, "ReasoningEffort", {
+	enumerable: true,
+	get: function() {
+		return ReasoningEffort;
+	}
+});
+Object.defineProperty(exports, "ReasoningMode", {
+	enumerable: true,
+	get: function() {
+		return ReasoningMode;
 	}
 });
 Object.defineProperty(exports, "ReasoningParameterFormat", {
@@ -8076,6 +10035,12 @@ Object.defineProperty(exports, "RunStatus", {
 		return RunStatus;
 	}
 });
+Object.defineProperty(exports, "SKILL_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return SKILL_FILTER_FIELDS;
+	}
+});
 Object.defineProperty(exports, "SKILL_SYNC_DEFAULT_DISCOVERY_DEPTH", {
 	enumerable: true,
 	get: function() {
@@ -8106,6 +10071,18 @@ Object.defineProperty(exports, "SSEOptionsSchema", {
 		return SSEOptionsSchema;
 	}
 });
+Object.defineProperty(exports, "STATEFUL_CODE_ENVIRONMENTS", {
+	enumerable: true,
+	get: function() {
+		return STATEFUL_CODE_ENVIRONMENTS;
+	}
+});
+Object.defineProperty(exports, "STORED_MESSAGE_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return STORED_MESSAGE_FILTER_FIELDS;
+	}
+});
 Object.defineProperty(exports, "STTProviders", {
 	enumerable: true,
 	get: function() {
@@ -8154,6 +10131,12 @@ Object.defineProperty(exports, "SettingsViews", {
 		return SettingsViews;
 	}
 });
+Object.defineProperty(exports, "SkillsScope", {
+	enumerable: true,
+	get: function() {
+		return SkillsScope;
+	}
+});
 Object.defineProperty(exports, "StdioOptionsSchema", {
 	enumerable: true,
 	get: function() {
@@ -8178,6 +10161,12 @@ Object.defineProperty(exports, "SystemCategories", {
 		return SystemCategories;
 	}
 });
+Object.defineProperty(exports, "TOOL_ARGUMENT_FILTER_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return TOOL_ARGUMENT_FILTER_FIELDS;
+	}
+});
 Object.defineProperty(exports, "TTSProviders", {
 	enumerable: true,
 	get: function() {
@@ -8268,6 +10257,24 @@ Object.defineProperty(exports, "actionDomainSeparator", {
 		return actionDomainSeparator;
 	}
 });
+Object.defineProperty(exports, "actionMetadataFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return actionMetadataFilterFieldSchema;
+	}
+});
+Object.defineProperty(exports, "agentGitIdentitySchema", {
+	enumerable: true,
+	get: function() {
+		return agentGitIdentitySchema;
+	}
+});
+Object.defineProperty(exports, "agentInstructionFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return agentInstructionFilterFieldSchema;
+	}
+});
 Object.defineProperty(exports, "agentsBaseSchema", {
 	enumerable: true,
 	get: function() {
@@ -8478,6 +10485,12 @@ Object.defineProperty(exports, "checkpointerTypeSchema", {
 		return checkpointerTypeSchema;
 	}
 });
+Object.defineProperty(exports, "clampSettingRange", {
+	enumerable: true,
+	get: function() {
+		return clampSettingRange;
+	}
+});
 Object.defineProperty(exports, "clearAllConversations", {
 	enumerable: true,
 	get: function() {
@@ -8490,6 +10503,24 @@ Object.defineProperty(exports, "cloudfrontConfigSchema", {
 		return cloudfrontConfigSchema;
 	}
 });
+Object.defineProperty(exports, "codeEnvironmentPermissionDecisionSchema", {
+	enumerable: true,
+	get: function() {
+		return codeEnvironmentPermissionDecisionSchema;
+	}
+});
+Object.defineProperty(exports, "codeEnvironmentUserConfigSchema", {
+	enumerable: true,
+	get: function() {
+		return codeEnvironmentUserConfigSchema;
+	}
+});
+Object.defineProperty(exports, "codeEnvironmentUserSettingsSchema", {
+	enumerable: true,
+	get: function() {
+		return codeEnvironmentUserSettingsSchema;
+	}
+});
 Object.defineProperty(exports, "codeInterpreterMimeTypes", {
 	enumerable: true,
 	get: function() {
@@ -8550,6 +10581,18 @@ Object.defineProperty(exports, "contextPruningSchema", {
 		return contextPruningSchema;
 	}
 });
+Object.defineProperty(exports, "conversationStarterFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return conversationStarterFilterFieldSchema;
+	}
+});
+Object.defineProperty(exports, "conversationTitleFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return conversationTitleFilterFieldSchema;
+	}
+});
 Object.defineProperty(exports, "convertStringsToRegex", {
 	enumerable: true,
 	get: function() {
@@ -8604,6 +10647,12 @@ Object.defineProperty(exports, "defaultEndpoints", {
 		return defaultEndpoints;
 	}
 });
+Object.defineProperty(exports, "defaultLLMDeliveryPathSchema", {
+	enumerable: true,
+	get: function() {
+		return defaultLLMDeliveryPathSchema;
+	}
+});
 Object.defineProperty(exports, "defaultModels", {
 	enumerable: true,
 	get: function() {
@@ -8808,6 +10857,12 @@ Object.defineProperty(exports, "extractVariableName", {
 		return extractVariableName;
 	}
 });
+Object.defineProperty(exports, "feedbackFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return feedbackFilterFieldSchema;
+	}
+});
 Object.defineProperty(exports, "feedbackRatingSchema", {
 	enumerable: true,
 	get: function() {
@@ -8838,6 +10893,12 @@ Object.defineProperty(exports, "fileConfigSchema", {
 		return fileConfigSchema;
 	}
 });
+Object.defineProperty(exports, "fileFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return fileFilterFieldSchema;
+	}
+});
 Object.defineProperty(exports, "fileSourceSchema", {
 	enumerable: true,
 	get: function() {
@@ -8856,6 +10917,36 @@ Object.defineProperty(exports, "fileStrategiesSchema", {
 		return fileStrategiesSchema;
 	}
 });
+Object.defineProperty(exports, "filterPiiActionSchema", {
+	enumerable: true,
+	get: function() {
+		return filterPiiActionSchema;
+	}
+});
+Object.defineProperty(exports, "filterPiiCustomPatternSchema", {
+	enumerable: true,
+	get: function() {
+		return filterPiiCustomPatternSchema;
+	}
+});
+Object.defineProperty(exports, "filterPiiRegexSchema", {
+	enumerable: true,
+	get: function() {
+		return filterPiiRegexSchema;
+	}
+});
+Object.defineProperty(exports, "filterPiiStarterPatternSchema", {
+	enumerable: true,
+	get: function() {
+		return filterPiiStarterPatternSchema;
+	}
+});
+Object.defineProperty(exports, "filtersConfigSchema", {
+	enumerable: true,
+	get: function() {
+		return filtersConfigSchema;
+	}
+});
 Object.defineProperty(exports, "fullMimeTypesList", {
 	enumerable: true,
 	get: function() {
@@ -8898,6 +10989,12 @@ Object.defineProperty(exports, "getAllEffectivePermissions", {
 		return getAllEffectivePermissions;
 	}
 });
+Object.defineProperty(exports, "getAllowedCodeApprovalModes", {
+	enumerable: true,
+	get: function() {
+		return getAllowedCodeApprovalModes;
+	}
+});
 Object.defineProperty(exports, "getAvailablePlugins", {
 	enumerable: true,
 	get: function() {
@@ -8934,6 +11031,12 @@ Object.defineProperty(exports, "getDefaultParamsEndpoint", {
 		return getDefaultParamsEndpoint;
 	}
 });
+Object.defineProperty(exports, "getDocumentFileExtension", {
+	enumerable: true,
+	get: function() {
+		return getDocumentFileExtension;
+	}
+});
 Object.defineProperty(exports, "getEffectivePermissions", {
 	enumerable: true,
 	get: function() {
@@ -8952,12 +11055,30 @@ Object.defineProperty(exports, "getEndpointFileConfig", {
 		return getEndpointFileConfig;
 	}
 });
+Object.defineProperty(exports, "getGoogleThinkingBudgetBounds", {
+	enumerable: true,
+	get: function() {
+		return getGoogleThinkingBudgetBounds;
+	}
+});
+Object.defineProperty(exports, "getGoogleThinkingBudgetMax", {
+	enumerable: true,
+	get: function() {
+		return getGoogleThinkingBudgetMax;
+	}
+});
 Object.defineProperty(exports, "getMCPServerConnectionStatus", {
 	enumerable: true,
 	get: function() {
 		return getMCPServerConnectionStatus;
 	}
 });
+Object.defineProperty(exports, "getMaxSubagents", {
+	enumerable: true,
+	get: function() {
+		return getMaxSubagents;
+	}
+});
 Object.defineProperty(exports, "getModelKey", {
 	enumerable: true,
 	get: function() {
@@ -8970,6 +11091,12 @@ Object.defineProperty(exports, "getModels", {
 		return getModels;
 	}
 });
+Object.defineProperty(exports, "getPiiRegexProgramSize", {
+	enumerable: true,
+	get: function() {
+		return getPiiRegexProgramSize;
+	}
+});
 Object.defineProperty(exports, "getRefillEligibilityDate", {
 	enumerable: true,
 	get: function() {
@@ -9054,12 +11181,36 @@ Object.defineProperty(exports, "googleSettings", {
 		return googleSettings;
 	}
 });
+Object.defineProperty(exports, "hasActiveFiltersConfig", {
+	enumerable: true,
+	get: function() {
+		return hasActiveFiltersConfig;
+	}
+});
+Object.defineProperty(exports, "hasActivePiiFields", {
+	enumerable: true,
+	get: function() {
+		return hasActivePiiFields;
+	}
+});
+Object.defineProperty(exports, "hasActivePiiPatterns", {
+	enumerable: true,
+	get: function() {
+		return hasActivePiiPatterns;
+	}
+});
 Object.defineProperty(exports, "hasPermissions", {
 	enumerable: true,
 	get: function() {
 		return hasPermissions;
 	}
 });
+Object.defineProperty(exports, "hasProcessMCPServerConfig", {
+	enumerable: true,
+	get: function() {
+		return hasProcessMCPServerConfig;
+	}
+});
 Object.defineProperty(exports, "hostImageIdSuffix", {
 	enumerable: true,
 	get: function() {
@@ -9168,6 +11319,30 @@ Object.defineProperty(exports, "isBedrockDocumentType", {
 		return isBedrockDocumentType;
 	}
 });
+Object.defineProperty(exports, "isCodeEnvironmentMode", {
+	enumerable: true,
+	get: function() {
+		return isCodeEnvironmentMode;
+	}
+});
+Object.defineProperty(exports, "isCodeWorkspaceSelection", {
+	enumerable: true,
+	get: function() {
+		return isCodeWorkspaceSelection;
+	}
+});
+Object.defineProperty(exports, "isCodeWorkspaceSelectionErrorReason", {
+	enumerable: true,
+	get: function() {
+		return isCodeWorkspaceSelectionErrorReason;
+	}
+});
+Object.defineProperty(exports, "isCodeWorkspaceSelections", {
+	enumerable: true,
+	get: function() {
+		return isCodeWorkspaceSelections;
+	}
+});
 Object.defineProperty(exports, "isDocumentSupportedProvider", {
 	enumerable: true,
 	get: function() {
@@ -9180,6 +11355,24 @@ Object.defineProperty(exports, "isImageVisionTool", {
 		return isImageVisionTool;
 	}
 });
+Object.defineProperty(exports, "isKnownProviderIdentifier", {
+	enumerable: true,
+	get: function() {
+		return isKnownProviderIdentifier;
+	}
+});
+Object.defineProperty(exports, "isMediaSupportedProvider", {
+	enumerable: true,
+	get: function() {
+		return isMediaSupportedProvider;
+	}
+});
+Object.defineProperty(exports, "isMessageFileUpload", {
+	enumerable: true,
+	get: function() {
+		return isMessageFileUpload;
+	}
+});
 Object.defineProperty(exports, "isMythosClassModel", {
 	enumerable: true,
 	get: function() {
@@ -9204,18 +11397,48 @@ Object.defineProperty(exports, "isPermissiveMimeConfig", {
 		return isPermissiveMimeConfig;
 	}
 });
+Object.defineProperty(exports, "isProcessMCPServerConfig", {
+	enumerable: true,
+	get: function() {
+		return isProcessMCPServerConfig;
+	}
+});
+Object.defineProperty(exports, "isProcessMCPServerField", {
+	enumerable: true,
+	get: function() {
+		return isProcessMCPServerField;
+	}
+});
 Object.defineProperty(exports, "isRemoteOidcUrlAllowed", {
 	enumerable: true,
 	get: function() {
 		return isRemoteOidcUrlAllowed;
 	}
 });
+Object.defineProperty(exports, "isResponsesApiUpload", {
+	enumerable: true,
+	get: function() {
+		return isResponsesApiUpload;
+	}
+});
+Object.defineProperty(exports, "isSecureCodeEnvironmentControlURL", {
+	enumerable: true,
+	get: function() {
+		return isSecureCodeEnvironmentControlURL;
+	}
+});
 Object.defineProperty(exports, "isSensitiveEnvVar", {
 	enumerable: true,
 	get: function() {
 		return isSensitiveEnvVar;
 	}
 });
+Object.defineProperty(exports, "isSpeechProviderConfigured", {
+	enumerable: true,
+	get: function() {
+		return isSpeechProviderConfigured;
+	}
+});
 Object.defineProperty(exports, "isUUID", {
 	enumerable: true,
 	get: function() {
@@ -9228,24 +11451,60 @@ Object.defineProperty(exports, "langfuseConfigSchema", {
 		return langfuseConfigSchema;
 	}
 });
+Object.defineProperty(exports, "langfuseTraceConfigSchema", {
+	enumerable: true,
+	get: function() {
+		return langfuseTraceConfigSchema;
+	}
+});
+Object.defineProperty(exports, "listConfiguredSpeechProviders", {
+	enumerable: true,
+	get: function() {
+		return listConfiguredSpeechProviders;
+	}
+});
 Object.defineProperty(exports, "loginPage", {
 	enumerable: true,
 	get: function() {
 		return loginPage;
 	}
 });
+Object.defineProperty(exports, "materializeModelSpecEndpoints", {
+	enumerable: true,
+	get: function() {
+		return materializeModelSpecEndpoints;
+	}
+});
 Object.defineProperty(exports, "mbToBytes", {
 	enumerable: true,
 	get: function() {
 		return mbToBytes;
 	}
 });
+Object.defineProperty(exports, "mcpRefreshDefaults", {
+	enumerable: true,
+	get: function() {
+		return mcpRefreshDefaults;
+	}
+});
+Object.defineProperty(exports, "mediaSupportedProviders", {
+	enumerable: true,
+	get: function() {
+		return mediaSupportedProviders;
+	}
+});
 Object.defineProperty(exports, "megabyte", {
 	enumerable: true,
 	get: function() {
 		return megabyte;
 	}
 });
+Object.defineProperty(exports, "memoryFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return memoryFilterFieldSchema;
+	}
+});
 Object.defineProperty(exports, "memorySchema", {
 	enumerable: true,
 	get: function() {
@@ -9258,6 +11517,12 @@ Object.defineProperty(exports, "mergeFileConfig", {
 		return mergeFileConfig;
 	}
 });
+Object.defineProperty(exports, "messageFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return messageFilterFieldSchema;
+	}
+});
 Object.defineProperty(exports, "messageFilterPiiSchema", {
 	enumerable: true,
 	get: function() {
@@ -9282,6 +11547,12 @@ Object.defineProperty(exports, "modelConfigSchema", {
 		return modelConfigSchema;
 	}
 });
+Object.defineProperty(exports, "modelParameterFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return modelParameterFilterFieldSchema;
+	}
+});
 Object.defineProperty(exports, "modelSpecSubagentsSchema", {
 	enumerable: true,
 	get: function() {
@@ -9306,6 +11577,12 @@ Object.defineProperty(exports, "normalizeMCPToolKey", {
 		return normalizeMCPToolKey;
 	}
 });
+Object.defineProperty(exports, "normalizeSearxngEngines", {
+	enumerable: true,
+	get: function() {
+		return normalizeSearxngEngines;
+	}
+});
 Object.defineProperty(exports, "normalizeServerName", {
 	enumerable: true,
 	get: function() {
@@ -9372,6 +11649,12 @@ Object.defineProperty(exports, "principalSchema", {
 		return principalSchema;
 	}
 });
+Object.defineProperty(exports, "promptFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return promptFilterFieldSchema;
+	}
+});
 Object.defineProperty(exports, "providerEndpointMap", {
 	enumerable: true,
 	get: function() {
@@ -9426,12 +11709,66 @@ Object.defineProperty(exports, "resetPassword", {
 		return resetPassword;
 	}
 });
+Object.defineProperty(exports, "resolveAgentSkillsScope", {
+	enumerable: true,
+	get: function() {
+		return resolveAgentSkillsScope;
+	}
+});
+Object.defineProperty(exports, "resolveAllowedStatefulCodeEnvironments", {
+	enumerable: true,
+	get: function() {
+		return resolveAllowedStatefulCodeEnvironments;
+	}
+});
+Object.defineProperty(exports, "resolveCodeApprovalMode", {
+	enumerable: true,
+	get: function() {
+		return resolveCodeApprovalMode;
+	}
+});
+Object.defineProperty(exports, "resolveCodePermissionDecision", {
+	enumerable: true,
+	get: function() {
+		return resolveCodePermissionDecision;
+	}
+});
 Object.defineProperty(exports, "resolveEndpointType", {
 	enumerable: true,
 	get: function() {
 		return resolveEndpointType;
 	}
 });
+Object.defineProperty(exports, "resolveModelSpecEndpoint", {
+	enumerable: true,
+	get: function() {
+		return resolveModelSpecEndpoint;
+	}
+});
+Object.defineProperty(exports, "resolveSandboxFilename", {
+	enumerable: true,
+	get: function() {
+		return resolveSandboxFilename;
+	}
+});
+Object.defineProperty(exports, "resolveStatefulCodeEnvironment", {
+	enumerable: true,
+	get: function() {
+		return resolveStatefulCodeEnvironment;
+	}
+});
+Object.defineProperty(exports, "resolveTraceViewerConfig", {
+	enumerable: true,
+	get: function() {
+		return resolveTraceViewerConfig;
+	}
+});
+Object.defineProperty(exports, "resolveUseResponsesApi", {
+	enumerable: true,
+	get: function() {
+		return resolveUseResponsesApi;
+	}
+});
 Object.defineProperty(exports, "resourcePermissionsResponseSchema", {
 	enumerable: true,
 	get: function() {
@@ -9486,6 +11823,12 @@ Object.defineProperty(exports, "setFileConfigRegexCompiler", {
 		return setFileConfigRegexCompiler;
 	}
 });
+Object.defineProperty(exports, "setMaxSubagents", {
+	enumerable: true,
+	get: function() {
+		return setMaxSubagents;
+	}
+});
 Object.defineProperty(exports, "setMessageFilterRegexValidator", {
 	enumerable: true,
 	get: function() {
@@ -9504,6 +11847,12 @@ Object.defineProperty(exports, "sharedFileDownload", {
 		return sharedFileDownload;
 	}
 });
+Object.defineProperty(exports, "skillFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return skillFilterFieldSchema;
+	}
+});
 Object.defineProperty(exports, "skillSyncConfigSchema", {
 	enumerable: true,
 	get: function() {
@@ -9540,6 +11889,24 @@ Object.defineProperty(exports, "splitToolCallName", {
 		return splitToolCallName;
 	}
 });
+Object.defineProperty(exports, "stripServerNamePrefix", {
+	enumerable: true,
+	get: function() {
+		return stripServerNamePrefix;
+	}
+});
+Object.defineProperty(exports, "stripServerNamePrefixes", {
+	enumerable: true,
+	get: function() {
+		return stripServerNamePrefixes;
+	}
+});
+Object.defineProperty(exports, "subagentThreadLineageSchema", {
+	enumerable: true,
+	get: function() {
+		return subagentThreadLineageSchema;
+	}
+});
 Object.defineProperty(exports, "summarizationConfigSchema", {
 	enumerable: true,
 	get: function() {
@@ -9678,6 +12045,24 @@ Object.defineProperty(exports, "toolApprovalPolicySchema", {
 		return toolApprovalPolicySchema;
 	}
 });
+Object.defineProperty(exports, "toolArgumentFilterFieldSchema", {
+	enumerable: true,
+	get: function() {
+		return toolArgumentFilterFieldSchema;
+	}
+});
+Object.defineProperty(exports, "traceViewerDefaults", {
+	enumerable: true,
+	get: function() {
+		return traceViewerDefaults;
+	}
+});
+Object.defineProperty(exports, "traceViewerLimits", {
+	enumerable: true,
+	get: function() {
+		return traceViewerLimits;
+	}
+});
 Object.defineProperty(exports, "transactionsSchema", {
 	enumerable: true,
 	get: function() {
@@ -9696,6 +12081,12 @@ Object.defineProperty(exports, "turnstileSchema", {
 		return turnstileSchema;
 	}
 });
+Object.defineProperty(exports, "unattributedAssistantContentSchema", {
+	enumerable: true,
+	get: function() {
+		return unattributedAssistantContentSchema;
+	}
+});
 Object.defineProperty(exports, "updateFeedback", {
 	enumerable: true,
 	get: function() {
@@ -9756,6 +12147,12 @@ Object.defineProperty(exports, "userKeyQuery", {
 		return userKeyQuery;
 	}
 });
+Object.defineProperty(exports, "userSubmittedMessageFieldPathSchema", {
+	enumerable: true,
+	get: function() {
+		return userSubmittedMessageFieldPathSchema;
+	}
+});
 Object.defineProperty(exports, "validateSettingDefinitions", {
 	enumerable: true,
 	get: function() {
@@ -9799,4 +12196,4 @@ Object.defineProperty(exports, "webSearchSchema", {
 	}
 });
 
-//# sourceMappingURL=data-service-DOIF4BkW.js.map
+//# sourceMappingURL=data-service-CTX0tVO5.js.map