librechat-data-provider 0.8.509 → 0.8.522

package/dist/index.mjs

@@ -1,17 +1,21 @@
-import { $ as permissionEntrySchema, $a as feedbackSchema, $i as extendedModelEndpointSchema, $n as MCP_USER_INPUT_FIELDS, $r as specsConfigSchema, $t as balanceSchema, Aa as tPluginAuthConfigSchema, Ai as anthropicSettings, An as modularEndpoints, Ar as fileConfig, At as SKILL_SYNC_MAX_INTERVAL_MINUTES, B as MutationKeys, Ba as RunStatus, Bi as defaultAssistantFormValues, Bn as summarizationTriggerSchema, Br as mbToBytes, Bt as TTSProviders, Ca as tBannerSchema, Ci as ThinkingLevel, Cn as initialModelsConfig, Cr as defaultOCRMimeTypes, Ct as MAX_SUBAGENT_RUN_CONFIGS, Da as tExampleSchema, Di as agentsSettings, Dn as messageFilterPiiSchema, Dr as endpointFileConfigSchema, Dt as RetentionMode, Ea as tConvoUpdateSchema, Ei as agentsSchema, En as memorySchema, Er as documentParserMimeTypes, Et as RerankerTypes, F as request_default, Fa as AnnotationTypes, Fi as compactAgentsBaseSchema, Fn as resolveEndpointType, Fr as imageMimeTypes, Ft as SearchCategories, G as PrincipalType, Ga as defaultOrderQuery, Gi as eReasoningEffortSchema, Gn as validateVisionModel, Gr as retrievalMimeTypesList, Gt as allowedAddressesSchema, H as AccessRoleIds, Ha as Tools, Hi as eAnthropicEffortSchema, Hn as transactionsSchema, Hr as mergeFileConfig, Ht as ViolationTypes, I as getTokenHeader, Ia as AssistantStreamEvents, Ii as compactAgentsSchema, In as skillSyncConfigSchema, Ir as imageTypeMapping, It as SearchProviders, J as accessRoleToPermBits, Ja as isActionTool, Ji as eReasoningSummarySchema, Jn as visionModels, Jr as textMimeTypes, Jt as assistantEndpointSchema, K as ResourceType, Ka as hostImageIdSuffix, Ki as eReasoningParameterFormatSchema, Kn as vertexAISchema, Kr as supportedMimeTypes, Kt as alternateName, L as setAcceptLanguageHeader, La as EToolResources, Li as compactAssistantSchema, Ln as skillSyncGitHubSourceSchema, Lr as inferMimeType, Lt as SettingsTabValues, Ma as tPresetSchema, Mi as authTypeSchema, Mn as paramDefinitionSchema, Mr as fullMimeTypesList, Mt as STTProviders, Na as tQueryParamsSchema, Ni as cacheSubsetProviders, Nn as providerEndpointMap, Nr as getEndpointFileConfig, Nt as SafeSearchTypes, Oa as tMessageSchema, Oi as anthropicBaseSchema, On as messageFilterSchema, Or as excelFileTypes, Ot as SKILL_SYNC_DEFAULT_DISCOVERY_DEPTH, Pa as tSharedLinkSchema, Pi as coerceNumber, Pn as rateLimitSchema, Pr as imageExtRegex, Pt as ScraperProviders, Q as permBitsToAccessLevel, Qa as feedbackRatingSchema, Qi as endpointSettings, Qn as MCPServersSchema, Qr as modelSpecSubagentsSchema, Qt as azureGroupSchema, R as setTokenHeader, Ra as FilePurpose, Ri as compactGoogleSchema, Rn as specialVariables, Rr as isBedrockDocumentType, Rt as SettingsViews, Sa as removeNullishValues, Si as ThinkingDisplay, Sn as imageGenTools, Sr as convertStringsToRegex, St as MAX_SUBAGENT_GRAPH_NODES, Ta as tConversationTagSchema, Ti as agentsBaseSchema, Tn as isRemoteOidcUrlAllowed, Tr as defaultTextMimeTypes, Tt as RateLimitPrefix, U as PermissionBits, Ua as actionDelimiter, Ui as eImageDetailSchema, Un as turnstileOptionsSchema, Ur as mimeTypeAliases, Ut as VisionModes, V as QueryKeys, Va as StepStatus, Vi as documentSupportedProviders, Vn as supportsBalanceCheck, Vr as megabyte, Vt as Time, W as PrincipalModel, Wa as actionDomainSeparator, Wi as eModelEndpointSchema, Wn as turnstileSchema, Wr as retrievalMimeTypes, Wt as agentsEndpointSchema, X as getResourcePermissionsResponseSchema, Xa as FEEDBACK_REASON_KEYS, Xi as eThinkingLevelSchema, Xn as MCPOptionsSchema, Xr as REFILL_INTERVAL_UNITS, Xt as azureEndpointSchema, Y as effectivePermissionsResponseSchema, Ya as FEEDBACK_RATINGS, Yi as eThinkingDisplaySchema, Yn as webSearchSchema, Yr as videoMimeTypes, Yt as azureBaseSchema, Z as hasPermissions, Za as FEEDBACK_TAGS, Zi as eVerbositySchema, Zn as MCPServerUserInputSchema, Zr as getRefillEligibilityDate, Zt as azureGroupConfigsSchema, _a as openAIBaseSchema, _i as Providers, _n as fileStrategiesSchema, _r as bedrockDocumentExtensions, _t as ImageDetailCost, a as data_service_exports, aa as googleSettings, ai as generateDynamicSchema, an as configSchema, ao as extractEnvVariable, ar as AuthorizationTypeEnum, at as AuthKeys, ba as openRouterSchema, bi as ReasoningResponseKey, bn as getEndpointField, br as codeInterpreterMimeTypesList, bt as LocalStorageKeys, ca as inputTokensIncludesCache, ci as validateSettingDefinitions, cn as defaultAssistantsVersion, co as normalizeEndpointName, cr as FileSources, ct as Capabilities, da as isDocumentSupportedProvider, di as BedrockProviders, dn as defaultRetrievalModels, dr as buildLoginRedirectUrl, dt as DEFAULT_MEMORY_MAX_INPUT_TOKENS, ea as getModelKey, ei as tModelSpecSchema, en as baseEndpointSchema, eo as feedbackTagKeySchema, er as SSEOptionsSchema, et as principalSchema, fa as isImageVisionTool, fi as BedrockReasoningConfig, fn as defaultSocialLogins, fr as loginPage, ft as EImageOutputType, ga as isUUID, gi as MYTHOS_CLASS_FAMILIES, gn as fileStorageSchema, gr as audioMimeTypes, gt as ForkOptions, ha as isParamEndpoint, hi as ImageVisionTool, hn as fileSourceSchema, hr as applicationMimeTypes, ht as FetchTokenConfig, ia as googleSchema, ii as SettingTypes, in as cloudfrontConfigSchema, io as envVarRegex, ir as AuthTypeEnum, it as AgentCapabilities, ja as tPluginSchema, ji as assistantSchema, jn as ocrSchema, jr as fileConfigSchema, jt as SKILL_SYNC_MIN_INTERVAL_MINUTES, ka as tModelSpecPresetSchema, ki as anthropicSchema, kn as modelConfigSchema, kr as excelMimeTypes, kt as SKILL_SYNC_MAX_DISCOVERY_DEPTH, la as isAgentsEndpoint, li as AnthropicEffort, ln as defaultEndpoints, lr as checkOpenAIStorage, lt as CohereConstants, ma as isOpenAILikeProvider, mi as ImageDetail, mn as excludedKeys, mr as sharedFileDownload, mt as ErrorTypes, na as googleBaseSchema, ni as ComponentTypes, nn as bedrockGuardrailConfigSchema, no as getTagsForRating, nr as StreamableHTTPOptionsSchema, nt as updateResourcePermissionsRequestSchema, oa as imageDetailNumeric, oi as generateGoogleSchema, on as contextPruningSchema, oo as extractVariableName, or as TokenExchangeMethodEnum, ot as BASE_ONLY_CONFIG_SECTIONS, pa as isMythosClassModel, pi as EModelEndpoint, pn as endpointSchema, pr as registerPage, pt as EndpointURLs, q as accessRoleSchema, qa as hostImageNamePrefix, qi as eReasoningResponseKeySchema, qn as vertexModelConfigSchema, qr as supportsFiles, qt as anthropicEndpointSchema, ra as googleGenConfigSchema, ri as OptionTypes, rn as bedrockModels, ro as toMinimalFeedback, rr as WebSocketOptionsSchema, rt as updateResourcePermissionsResponseSchema, sa as imageDetailValue, si as generateOpenAISchema, sn as defaultAgentCapabilities, so as isSensitiveEnvVar, sr as FileContext, st as CacheKeys, ta as getSettingsKeys, ti as MAX_SUBAGENTS, tn as bedrockEndpointSchema, to as getTagByKey, tr as StdioOptionsSchema, tt as resourcePermissionsResponseSchema, ua as isAssistantsEndpoint, ui as AuthType, un as defaultModels, ur as apiBaseUrl, ut as Constants, va as openAISchema, vi as ReasoningEffort, vn as getConfigDefaults, vr as bedrockDocumentFormats, vt as InfiniteCollections, wa as tConversationSchema, wi as Verbosity, wn as interfaceSchema, wr as defaultSTTMimeTypes, wt as OCRStrategy, xa as paramEndpoints, xi as ReasoningSummary, xn as getSchemaDefaults, xr as codeTypeMapping, xt as MAX_SUBAGENT_DEPTH, ya as openAISettings, yi as ReasoningParameterFormat, yn as getDefaultParamsEndpoint, yr as codeInterpreterMimeTypes, yt as KnownEndpoints, z as DynamicQueryKeys, za as MessageContentTypes, zi as defaultAgentFormValues, zn as summarizationConfigSchema, zr as isPermissiveMimeConfig, zt as SystemCategories } from "./data-service-BsdHkdKS.mjs";
+import { $ as permissionEntrySchema, $a as googleSchema, $i as BedrockReasoningConfig, $n as specialVariables, $o as feedbackSchema, $r as defaultTextMimeTypes, $s as normalizeEndpointName, $t as azureGroupConfigsSchema, Aa as defaultAgentFormValues, Ai as materializeModelSpecEndpoints, An as imageGenTools, Ao as tQueryParamsSchema, Ar as isProcessMCPServerField, As as feedbackFilterFieldSchema, At as SKILL_SYNC_DEFAULT_DISCOVERY_DEPTH, B as MutationKeys, Ba as eReasoningResponseKeySchema, Bi as getMaxSubagents, Bn as modularEndpoints, Bo as actionDelimiter, Br as registerPage, Bs as hasActivePiiPatterns, Bt as SettingsViews, Ca as authTypeSchema, Ci as setFileConfigRegexCompiler, Cn as fileSourceSchema, Co as tConvoUpdateSchema, Cr as MCP_USER_INPUT_FIELDS, Cs as SKILL_FILTER_FIELDS, Ct as MAX_SUBAGENT_DEPTH, Da as compactAgentsSchema, Di as videoMimeTypes, Dn as getDefaultParamsEndpoint, Do as tPluginAuthConfigSchema, Dr as WebSocketOptionsSchema, Ds as agentInstructionFilterFieldSchema, Dt as RateLimitPrefix, Ea as compactAgentsBaseSchema, Ei as textMimeTypes, En as getConfigDefaults, Eo as tModelSpecPresetSchema, Er as StreamableHTTPOptionsSchema, Es as actionMetadataFilterFieldSchema, Et as OCRStrategy, F as request_default, Fa as eModelEndpointSchema, Fi as MAX_CHAT_PROJECT_DESCRIPTION_LENGTH, Fn as langfuseConfigSchema, Fo as FilePurpose, Fr as FileSources, Fs as filterPiiStarterPatternSchema, Ft as SafeSearchTypes, G as PrincipalType, Ga as endpointSettings, Gi as clampSettingRange, Gn as paramDefinitionSchema, Go as isActionTool, Gr as bedrockDocumentFormats, Gs as skillFilterFieldSchema, Gt as VisionModes, H as AccessRoleIds, Ha as eThinkingDisplaySchema, Hi as ComponentTypes, Hn as normalizeSearxngEngines, Ho as defaultOrderQuery, Hr as applicationMimeTypes, Hs as messageFilterFieldSchema, Ht as TTSProviders, I as getTokenHeader, Ia as eReasoningContextSchema, Ii as MAX_CHAT_PROJECT_NAME_LENGTH, In as memorySchema, Io as MessageContentTypes, Ir as checkOpenAIStorage, Is as filtersConfigSchema, It as ScraperProviders, J as accessRoleToPermBits, Ja as getGoogleThinkingBudgetMax, Ji as generateOpenAISchema, Jn as resolveEndpointType, Jo as resolveStatefulCodeEnvironment, Jr as codeInterpreterMimeTypesList, Js as userSubmittedMessageFieldPathSchema, Jt as alternateName, K as ResourceType, Ka as extendedModelEndpointSchema, Ki as generateDynamicSchema, Kn as providerEndpointMap, Ko as STATEFUL_CODE_ENVIRONMENTS, Kr as bedrockDocumentMimeTypes, Ks as toolArgumentFilterFieldSchema, Kt as agentsEndpointSchema, L as setAcceptLanguageHeader, La as eReasoningEffortSchema, Li as MAX_GRAPH_SUBAGENT_MEMBERS, Ln as messageFilterPiiSchema, Lo as RunStatus, Lr as apiBaseUrl, Ls as getPiiRegexProgramSize, Lt as SearchCategories, Ma as documentSupportedProviders, Mi as resolveModelSpecEndpoint, Mn as interfaceSchema, Mo as AnnotationTypes, Mr as AuthorizationTypeEnum, Ms as filterPiiActionSchema, Mt as SKILL_SYNC_MAX_INTERVAL_MINUTES, Na as eAnthropicEffortSchema, Ni as specsConfigSchema, Nn as isRemoteOidcUrlAllowed, No as AssistantStreamEvents, Nr as TokenExchangeMethodEnum, Ns as filterPiiCustomPatternSchema, Nt as SKILL_SYNC_MIN_INTERVAL_MINUTES, Oa as compactAssistantSchema, Oi as REFILL_INTERVAL_UNITS, On as getEndpointField, Oo as tPluginSchema, Or as hasProcessMCPServerConfig, Os as conversationStarterFilterFieldSchema, Ot as RerankerTypes, Pa as eImageDetailSchema, Pi as tModelSpecSchema, Pn as isSecureCodeEnvironmentControlURL, Po as EToolResources, Pr as FileContext, Ps as filterPiiRegexSchema, Pt as STTProviders, Q as permBitsToAccessLevel, Qa as googleGenConfigSchema, Qi as BedrockProviders, Qn as skillSyncGitHubSourceSchema, Qo as feedbackRatingSchema, Qr as defaultSTTMimeTypes, Qs as isSensitiveEnvVar, Qt as azureEndpointSchema, R as setTokenHeader, Ra as eReasoningModeSchema, Ri as MAX_SUBAGENTS, Rn as messageFilterSchema, Ro as StepStatus, Rr as buildLoginRedirectUrl, Rs as hasActiveFiltersConfig, Rt as SearchProviders, Sa as assistantSchema, Si as retrievalMimeTypesList, Sn as excludedKeys, So as tConversationTagSchema, Sr as MCP_SERVER_TITLE_PATTERN, Ss as PROMPT_FILTER_FIELDS, St as LocalStorageKeys, Ta as coerceNumber, Ti as supportsFiles, Tn as fileStrategiesSchema, To as tMessageSchema, Tr as StdioOptionsSchema, Ts as TOOL_ARGUMENT_FILTER_FIELDS, Tt as MAX_SUBAGENT_RUN_CONFIGS, U as PermissionBits, Ua as eThinkingLevelSchema, Ui as OptionTypes, Un as normalizeServerName, Uo as hostImageIdSuffix, Ur as audioMimeTypes, Us as modelParameterFilterFieldSchema, Ut as Time, V as QueryKeys, Va as eReasoningSummarySchema, Vi as setMaxSubagents, Vn as normalizeMCPToolKey, Vo as actionDomainSeparator, Vr as sharedFileDownload, Vs as memoryFilterFieldSchema, Vt as SystemCategories, W as PrincipalModel, Wa as eVerbositySchema, Wi as SettingTypes, Wn as ocrSchema, Wo as hostImageNamePrefix, Wr as bedrockDocumentExtensions, Ws as promptFilterFieldSchema, Wt as ViolationTypes, X as getResourcePermissionsResponseSchema, Xa as getSettingsKeys, Xi as AnthropicEffort, Xn as setMessageFilterRegexValidator, Xo as FEEDBACK_REASON_KEYS, Xr as convertStringsToRegex, Xs as extractEnvVariable, Xt as assistantEndpointSchema, Y as effectivePermissionsResponseSchema, Ya as getModelKey, Yi as validateSettingDefinitions, Yn as retainRecentConfigSchema, Yo as FEEDBACK_RATINGS, Yr as codeTypeMapping, Ys as envVarRegex, Yt as anthropicEndpointSchema, Z as hasPermissions, Za as googleBaseSchema, Zi as AuthType, Zn as skillSyncConfigSchema, Zo as FEEDBACK_TAGS, Zr as defaultOCRMimeTypes, Zs as extractVariableName, Zt as azureBaseSchema, _a as agentsSchema, _i as mbToBytes, _n as defaultEndpoints, _o as removeNullishValues, _r as webSearchSchema, _s as MAX_PII_PATTERN_LABEL_LENGTH, _t as FetchTokenConfig, a as data_service_exports, aa as Providers, ai as fileConfigSchema, an as bedrockModels, ao as isAssistantsEndpoint, ar as summarizationTriggerSchema, as as AGENT_INSTRUCTION_FILTER_FIELDS, at as AgentCapabilities, ba as anthropicSchema, bi as mimeTypeAliases, bn as defaultSocialLogins, bo as tBannerSchema, br as MCPServersSchema, bs as MESSAGE_FILTER_FIELDS, bt as InfiniteCollections, ca as ReasoningMode, ci as getEndpointFileConfig, cn as checkpointerTypeSchema, co as isMythosClassModel, cr as toolApprovalModeSchema, cs as FEEDBACK_FILTER_FIELDS, ct as BASE_PRINCIPAL_CONFIG_SECTIONS, da as ReasoningSummary, di as imageTypeMapping, dn as codeEnvironmentUserConfigSchema, do as isUUID, dr as turnstileOptionsSchema, ds as HITL_MESSAGE_FILTER_FIELDS, dt as CohereConstants, ea as EModelEndpoint, ei as documentParserMimeTypes, en as azureGroupSchema, eo as googleSettings, er as splitMCPToolKey, es as feedbackTagKeySchema, et as principalSchema, fa as SkillsScope, fi as inferMimeType, fn as codeEnvironmentUserSettingsSchema, fo as openAIBaseSchema, fr as turnstileSchema, fs as MAX_PII_CUSTOM_PATTERNS_TOTAL, ft as Constants, ga as agentsBaseSchema, gi as isPermissiveMimeConfig, gn as defaultAssistantsVersion, go as paramEndpoints, gr as visionModels, gs as MAX_PII_PATTERN_ID_LENGTH, gt as ErrorTypes, ha as Verbosity, hi as isBedrockDocumentType, hn as defaultAgentCapabilities, ho as openRouterSchema, hr as vertexModelConfigSchema, hs as MAX_PII_PATTERNS_PER_SOURCE, ht as EndpointURLs, ia as MemoryScope, ii as fileConfig, in as bedrockGuardrailConfigSchema, io as isAgentsEndpoint, ir as summarizationConfigSchema, is as ACTION_METADATA_FILTER_FIELDS, it as AUTH_USER_DOC_BY_ID_PREFIX, ja as defaultAssistantFormValues, ji as modelSpecSubagentsSchema, jn as initialModelsConfig, jo as tSharedLinkSchema, jr as AuthTypeEnum, js as fileFilterFieldSchema, jt as SKILL_SYNC_MAX_DISCOVERY_DEPTH, ka as compactGoogleSchema, ki as getRefillEligibilityDate, kn as getSchemaDefaults, ko as tPresetSchema, kr as isProcessMCPServerConfig, ks as conversationTitleFilterFieldSchema, kt as RetentionMode, la as ReasoningParameterFormat, li as imageExtRegex, ln as cloudfrontConfigSchema, lo as isOpenAILikeProvider, lr as toolApprovalPolicySchema, ls as FILE_FILTER_FIELDS, lt as CacheKeys, ma as ThinkingLevel, mi as isAnthropicTextDocumentType, mn as contextPruningSchema, mo as openAISettings, mr as vertexAISchema, ms as MAX_PII_CUSTOM_REGEX_INSTRUCTIONS, mt as EImageOutputType, na as ImageVisionTool, ni as excelFileTypes, nn as baseEndpointSchema, no as imageDetailValue, nr as stripServerNamePrefix, ns as getTagsForRating, nt as updateResourcePermissionsRequestSchema, oa as ReasoningContext, oi as fullMimeTypesList, on as buildServerNameAliases, oo as isDocumentSupportedProvider, or as supportsBalanceCheck, os as CONVERSATION_STARTER_FILTER_FIELDS, ot as AuthKeys, pa as ThinkingDisplay, pi as isAnthropicDocumentType, pn as configSchema, po as openAISchema, pr as validateVisionModel, ps as MAX_PII_CUSTOM_REGEX_CHARACTERS, pt as DEFAULT_MEMORY_MAX_INPUT_TOKENS, q as accessRoleSchema, qa as getGoogleThinkingBudgetBounds, qi as generateGoogleSchema, qn as rateLimitSchema, qo as resolveAllowedStatefulCodeEnvironments, qr as codeInterpreterMimeTypes, qs as unattributedAssistantContentSchema, qt as allowedAddressesSchema, ra as MYTHOS_CLASS_FAMILIES, ri as excelMimeTypes, rn as bedrockEndpointSchema, ro as inputTokensIncludesCache, rr as stripServerNamePrefixes, rs as toMinimalFeedback, rt as updateResourcePermissionsResponseSchema, sa as ReasoningEffort, si as getConfiguredMimeAccept, sn as checkpointerSchema, so as isImageVisionTool, sr as toolApprovalHookConfigSchema, ss as CONVERSATION_TITLE_FILTER_FIELDS, st as BASE_ONLY_CONFIG_SECTIONS, ta as ImageDetail, ti as endpointFileConfigSchema, tn as balanceSchema, to as imageDetailNumeric, tr as splitToolCallName, ts as getTagByKey, tt as resourcePermissionsResponseSchema, ua as ReasoningResponseKey, ui as imageMimeTypes, un as codeEnvironmentPermissionDecisionSchema, uo as isParamEndpoint, ur as transactionsSchema, us as FILTER_PII_STARTER_PATTERNS, ut as Capabilities, va as agentsSettings, vi as megabyte, vn as defaultModels, vo as resolveAgentSkillsScope, vr as MCPOptionsSchema, vs as MAX_PII_PATTERN_LENGTH, vt as ForkOptions, wa as cacheSubsetProviders, wi as supportedMimeTypes, wn as fileStorageSchema, wo as tExampleSchema, wr as SSEOptionsSchema, ws as STORED_MESSAGE_FILTER_FIELDS, wt as MAX_SUBAGENT_GRAPH_NODES, xa as anthropicSettings, xi as retrievalMimeTypes, xn as endpointSchema, xo as tConversationSchema, xr as MCP_SERVER_TITLE_ERROR, xs as MODEL_PARAMETER_FILTER_FIELDS, xt as KnownEndpoints, ya as anthropicBaseSchema, yi as mergeFileConfig, yn as defaultRetrievalModels, yo as subagentThreadLineageSchema, yr as MCPServerUserInputSchema, ys as MEMORY_FILTER_FIELDS, yt as ImageDetailCost, z as DynamicQueryKeys, za as eReasoningParameterFormatSchema, zi as MAX_SUBAGENTS_CEILING, zn as modelConfigSchema, zo as Tools, zr as loginPage, zs as hasActivePiiFields, zt as SettingsTabValues } from "./data-service-CaB7saTP.mjs";
 import { z } from "zod";
 import dayjs from "dayjs";
 import utc from "dayjs/plugin/utc.js";
 import timezonePlugin from "dayjs/plugin/timezone.js";
+import { Cron } from "croner";
 import axios from "axios";
 import { URL } from "url";
 import crypto from "crypto";
 import { load } from "js-yaml";
 //#region src/bedrock.ts
-const DEFAULT_ENABLED_MAX_TOKENS = 8192;
 const DEFAULT_THINKING_BUDGET = 2e3;
+const BEDROCK_CLAUDE_SONNET_4_6_MAX_OUTPUT = 64e3;
 const BEDROCK_OUTPUT_128K_BETA = "output-128k-2025-02-19";
 const BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+/** Betas LibreChat injects itself, safe to strip from persisted AMRF when a
+* model no longer supports them; anything else in `anthropic_beta` is a user opt-in. */
+const GENERATED_BEDROCK_BETAS = new Set([BEDROCK_OUTPUT_128K_BETA, BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA]);
 const bedrockReasoningConfigValues = new Set(Object.values(BedrockReasoningConfig));
 /**
 * Resolves the final `thinking.display` value for an adaptive-thinking request.
@@ -56,14 +60,14 @@ function parseOpusVersion(model) {
 	return null;
 }
 /** Extracts sonnet major/minor version from both naming formats.
-*  Uses single-digit minor capture to avoid matching date suffixes (e.g., -20250514). */
+*  Uses bounded minor capture to avoid matching date suffixes (e.g., -20250514). */
 function parseSonnetVersion(model) {
-	const nameFirst = model.match(/claude-sonnet[-.]?(\d+)(?:[-.](\d)(?!\d))?/);
+	const nameFirst = model.match(/claude-sonnet[-.]?(\d+)(?:[-.](\d{1,2})(?!\d))?/);
 	if (nameFirst) return {
 		major: parseInt(nameFirst[1], 10),
 		minor: nameFirst[2] != null ? parseInt(nameFirst[2], 10) : 0
 	};
-	const numFirst = model.match(/claude-(\d+)(?:[-.](\d)(?!\d))?-sonnet/);
+	const numFirst = model.match(/claude-(\d+)(?:[-.](\d{1,2})(?!\d))?-sonnet/);
 	if (numFirst) return {
 		major: parseInt(numFirst[1], 10),
 		minor: numFirst[2] != null ? parseInt(numFirst[2], 10) : 0
@@ -97,15 +101,80 @@ function supportsAdaptiveThinking(model) {
 function omitsThinkingByDefault(model) {
 	const opus = parseOpusVersion(model);
 	if (opus && (opus.major > 4 || opus.major === 4 && opus.minor >= 7)) return true;
+	const sonnet = parseSonnetVersion(model);
+	if (sonnet != null && sonnet.major >= 5) return true;
 	if (isMythosClassModel(model)) return true;
 	return false;
 }
 function omitsSamplingParameters(model) {
 	const opus = parseOpusVersion(model);
 	if (opus && (opus.major > 4 || opus.major === 4 && opus.minor >= 7)) return true;
+	const sonnet = parseSonnetVersion(model);
+	if (sonnet != null && sonnet.major >= 5) return true;
 	if (isMythosClassModel(model)) return true;
 	return false;
 }
+/**
+* Whether disabling thinking requires sending an explicit `{ type: 'disabled' }`
+* config rather than simply omitting the `thinking` field.
+*
+* Sonnet 5 and Opus 5 treat an omitted `thinking` field as adaptive thinking ON
+* by default, so honoring a user who turns thinking off means sending the
+* disabled config explicitly. Opus 4.7/4.8 run without thinking when the field
+* is omitted, and Fable/Mythos reject an explicit disabled config (400,
+* thinking always on), so both are excluded.
+*
+* See https://platform.claude.com/docs/en/about-claude/models/migration-guide#migrating-to-claude-sonnet-5
+*/
+function requiresExplicitThinkingDisabled(model) {
+	const sonnet = parseSonnetVersion(model);
+	if (sonnet != null && sonnet.major >= 5) return true;
+	const opus = parseOpusVersion(model);
+	return opus != null && opus.major >= 5;
+}
+/** Effort levels Opus 5 rejects while thinking is explicitly disabled. */
+const EFFORTS_REJECTED_WHEN_THINKING_DISABLED = new Set(["xhigh", "max"]);
+/**
+* Whether the model caps `output_config.effort` while thinking is disabled.
+*
+* Opus 5 rejects `xhigh`/`max` in that combination with a 400: "output_config
+* .effort 'xhigh' is not supported when thinking is disabled on this model. Use
+* effort 'high' or below, or enable thinking." Opus 4.7/4.8, Sonnet 5, and
+* Sonnet 4.6 accept every effort level they otherwise support with thinking
+* off, so the cap is Opus 5+ only.
+*/
+function capsEffortWhenThinkingDisabled(model) {
+	const opus = parseOpusVersion(model);
+	return opus != null && opus.major >= 5;
+}
+/**
+* Lowers an effort level the model would reject while thinking is disabled to
+* the highest accepted value (`high`, which is also the API default). Returns
+* the effort unchanged when the combination is valid.
+*/
+function clampEffortForDisabledThinking(model, effort) {
+	if (capsEffortWhenThinkingDisabled(model) && EFFORTS_REJECTED_WHEN_THINKING_DISABLED.has(effort)) return "high";
+	return effort;
+}
+/** An `output_config` container carrying a usable effort level. */
+function hasStringEffort(value) {
+	if (typeof value !== "object" || value === null || !("effort" in value)) return false;
+	return typeof value.effort === "string";
+}
+/**
+* Clamps an `output_config.effort` in place when the model would reject it
+* while thinking is disabled. No-op when the container carries no string
+* effort, so callers can pass a possibly-absent config directly.
+*/
+function clampOutputConfigEffort(model, outputConfig) {
+	if (!hasStringEffort(outputConfig)) return;
+	outputConfig.effort = clampEffortForDisabledThinking(model, outputConfig.effort);
+}
+/** Whether a resolved thinking config is an explicit `{ type: 'disabled' }`. */
+function isThinkingDisabled(thinking) {
+	if (typeof thinking !== "object" || thinking === null || !("type" in thinking)) return false;
+	return thinking.type === "disabled";
+}
 /** Checks if a model has a 1M context window (Sonnet 4.6+, Opus 4.6+, Opus 5+, Fable/Mythos) */
 function supportsContext1m(model) {
 	const sonnet = parseSonnetVersion(model);
@@ -116,6 +185,30 @@ function supportsContext1m(model) {
 	return false;
 }
 /**
+* Checks whether a native Anthropic Claude model supports prompt caching.
+*
+* This uses the configured model ID directly. Resolving it through a token
+* map first can collapse a newly released Claude model to the generic
+* `claude-` fallback and incorrectly disable cache control.
+*/
+function supportsPromptCache(model) {
+	if (model.includes("claude-3-5-sonnet-latest") || model.includes("claude-3.5-sonnet-latest")) return false;
+	return /claude-3[-.]7/.test(model) || /claude-3[-.]5-(?:sonnet|haiku)/.test(model) || /claude-3-(?:sonnet|haiku|opus)?/.test(model) || /claude-(?:sonnet|opus|haiku)[-.]?(?:[4-9]|\d{2,})/.test(model) || /claude-(?:[4-9]|\d{2,})(?:[-.](?:sonnet|opus|haiku))?/.test(model) || isMythosClassModel(model);
+}
+/**
+* A Bedrock Claude model ID may be prefixed (`anthropic.claude-*`,
+* `us.anthropic.claude-*`, `global.anthropic.claude-*`) or bare (`claude-*`,
+* used when the LibreChat model ID maps to an application inference profile).
+* Match on the `claude` family token so every form is recognized — requiring
+* the literal `anthropic.` prefix silently dropped thinking config, beta
+* headers, and sampling handling for inference-profile deployments.
+*/
+const BEDROCK_CLAUDE_4PLUS_THINKING = /claude-(?:[4-9](?:\.\d+)?(?:-\d+)?-(?:sonnet|opus|haiku)|(?:sonnet|opus|haiku)-[4-9])/;
+/** Whether a Bedrock model ID is an Anthropic Claude model (prefixed or bare). */
+function isBedrockClaudeModel(model) {
+	return model.includes("claude");
+}
+/**
 * Gets the appropriate anthropic_beta headers for Bedrock Anthropic models.
 * Bedrock uses `anthropic_beta` (with underscore) in additionalModelRequestFields.
 *
@@ -126,19 +219,33 @@ function getBedrockAnthropicBetaHeaders(model) {
 	const betaHeaders = [];
 	/** Mythos-class (Fable/Mythos) is intentionally not matched: these betas are built-in/no-op for the
 	* 4.7+ generation (Fable has native 128K output), so omitting them on Bedrock is lossless. */
-	const isClaude4PlusModel = /anthropic\.claude-(?:[4-9](?:\.\d+)?(?:-\d+)?-(?:sonnet|opus|haiku)|(?:sonnet|opus|haiku)-[4-9])/.test(model);
-	if (model.includes("anthropic.claude-3-7-sonnet") || isClaude4PlusModel) betaHeaders.push(BEDROCK_OUTPUT_128K_BETA);
+	const isClaude4PlusModel = BEDROCK_CLAUDE_4PLUS_THINKING.test(model);
+	if (model.includes("claude-3-7-sonnet") || isClaude4PlusModel) betaHeaders.push(BEDROCK_OUTPUT_128K_BETA);
 	if (isClaude4PlusModel) betaHeaders.push(BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA);
 	return betaHeaders;
 }
+/** Flatten an anthropic_beta value (array, single string, or comma-delimited
+* string) into trimmed, non-empty header tokens. */
+function normalizeBetaHeaders(value) {
+	let values = [];
+	if (Array.isArray(value)) values = value;
+	else if (typeof value === "string") values = [value];
+	const headers = [];
+	values.forEach((entry) => {
+		if (typeof entry !== "string") return;
+		entry.split(",").map((header) => header.trim()).filter(Boolean).forEach((header) => headers.push(header));
+	});
+	return headers;
+}
 function mergeBedrockAnthropicBetaHeaders(existing, generated) {
-	let existingValues = [];
-	if (Array.isArray(existing)) existingValues = existing;
-	else if (typeof existing === "string") existingValues = [existing];
+	const generatedSet = new Set(generated);
 	const betaHeaders = /* @__PURE__ */ new Set();
-	[...existingValues, ...generated].forEach((value) => {
-		if (typeof value !== "string") return;
-		value.split(",").map((header) => header.trim()).filter(Boolean).forEach((header) => betaHeaders.add(header));
+	[...normalizeBetaHeaders(existing), ...generated].forEach((header) => {
+		/** Drop a generated beta carried over from a prior model that the current
+		* model does not generate (e.g. fine-grained-tool-streaming on a 3.7
+		* profile); user opt-ins are always preserved. */
+		if (GENERATED_BEDROCK_BETAS.has(header) && !generatedSet.has(header)) return;
+		betaHeaders.add(header);
 	});
 	return Array.from(betaHeaders);
 }
@@ -172,7 +279,7 @@ const bedrockInputSchema = tConversationSchema.pick({
 }).transform((obj) => {
 	if (obj.additionalModelRequestFields?.thinking != null) {
 		const thinking = obj.additionalModelRequestFields.thinking;
-		obj.thinking = !!thinking;
+		obj.thinking = typeof thinking === "object" && thinking !== null && thinking.type === "disabled" ? false : !!thinking;
 		obj.thinkingBudget = typeof thinking === "object" && "budget_tokens" in thinking ? thinking.budget_tokens : void 0;
 		if (obj.thinkingDisplay == null) {
 			const persistedDisplay = extractPersistedDisplay({ thinking });
@@ -239,16 +346,49 @@ const bedrockInputParser = tConversationSchema.pick({
 			delete typedData[key];
 		}
 	});
-	/** Configure thinking for Bedrock Anthropic models: 3.7 Sonnet, Claude 4+ (opus/sonnet/haiku), and Mythos-class (Fable/Mythos). */
-	if (typeof typedData.model === "string" && (typedData.model.includes("anthropic.claude-3-7-sonnet") || /anthropic\.claude-(?:[4-9](?:\.\d+)?(?:-\d+)?-(?:sonnet|opus|haiku)|(?:sonnet|opus|haiku)-[4-9])/.test(typedData.model) || isMythosClassModel(typedData.model))) {
+	/**
+	* Persisted `model_parameters` can carry a prior "thinking off" only inside
+	* `additionalModelRequestFields.thinking = { type: 'disabled' }` (a known
+	* key that isn't spread into `additionalFields`). `initializeBedrock` feeds
+	* those params straight through this parser, so surface that as
+	* `thinking: false` — otherwise the disabled branch is skipped and the
+	* config rebuilds adaptive, flipping a user's Sonnet 5 setting back on.
+	*/
+	const persistedThinking = typedData.additionalModelRequestFields?.thinking;
+	if (additionalFields.thinking === void 0 && typeof persistedThinking === "object" && persistedThinking !== null && persistedThinking.type === "disabled") additionalFields.thinking = false;
+	/** Bedrock thinking-capable Claude models: 3.7 Sonnet, Claude 4+ (opus/sonnet/haiku), and Mythos-class (Fable/Mythos). */
+	const isThinkingModel = typeof typedData.model === "string" && (typedData.model.includes("claude-3-7-sonnet") || BEDROCK_CLAUDE_4PLUS_THINKING.test(typedData.model) || isMythosClassModel(typedData.model));
+	if (isThinkingModel) {
 		if (supportsAdaptiveThinking(typedData.model)) {
+			/** Persisted AMRF is spread into the final request, so clearing only
+			* `additionalFields` leaves a stale value from a prior selection. */
+			const persistedAmrf = typedData.additionalModelRequestFields;
+			const thinkingDisabled = additionalFields.thinking === false;
 			const effort = additionalFields.effort;
-			if (effort && typeof effort === "string" && effort !== "") additionalFields.output_config = { effort };
+			if (typeof effort === "string" && effort !== "") additionalFields.output_config = { effort };
+			else if (effort !== void 0 && persistedAmrf)
+ /** Explicit unset ('' or null) clears the persisted effort. An absent
+			* effort (agent resume, where the prior llmConfig persisted
+			* `output_config` but no top-level `effort`) preserves it. */
+			delete persistedAmrf.output_config;
 			delete additionalFields.effort;
+			/**
+			* Opus 5 rejects `xhigh`/`max` effort while thinking is disabled, so
+			* clamp both the effort derived above and any effort still carried in
+			* persisted AMRF (agent resume sends `output_config` with no top-level
+			* `effort`, so the branch above leaves it untouched).
+			*/
+			if (thinkingDisabled) [additionalFields, persistedAmrf].forEach((target) => clampOutputConfigEffort(typedData.model, target?.output_config));
 			if (additionalFields.thinking === false) {
-				delete additionalFields.thinking;
 				delete additionalFields.thinkingBudget;
 				delete additionalFields.thinkingDisplay;
+				if (requiresExplicitThinkingDisabled(typedData.model)) additionalFields.thinking = { type: "disabled" };
+				else {
+					delete additionalFields.thinking;
+					/** Disable-by-omission models (Opus 4.7+): drop the persisted
+					* adaptive config so turning thinking off actually disables it. */
+					if (persistedAmrf) delete persistedAmrf.thinking;
+				}
 			} else {
 				/**
 				* Persisted agent `model_parameters` round-trip back through this
@@ -276,10 +416,18 @@ const bedrockInputParser = tConversationSchema.pick({
 			if (additionalFields.thinking === true && additionalFields.thinkingBudget === void 0) additionalFields.thinkingBudget = DEFAULT_THINKING_BUDGET;
 			delete additionalFields.effort;
 			delete additionalFields.thinkingDisplay;
+			/** A bare non-adaptive thinking profile (e.g. `claude-3-7-sonnet`) must
+			* not inherit an adaptive/disabled thinking object or `output_config`
+			* persisted from another model; this branch's own fields are authoritative. */
+			const persistedAmrf = typedData.additionalModelRequestFields;
+			if (persistedAmrf) {
+				delete persistedAmrf.thinking;
+				delete persistedAmrf.output_config;
+			}
 		}
 		/** Anthropic uses 'effort' via output_config, not reasoning_config */
 		delete additionalFields.reasoning_effort;
-		if (typedData.model.includes("anthropic.")) {
+		if (isBedrockClaudeModel(typedData.model)) {
 			const betaHeaders = getBedrockAnthropicBetaHeaders(typedData.model);
 			if (betaHeaders.length > 0) {
 				const existingBetaHeaders = typedData.additionalModelRequestFields?.anthropic_beta;
@@ -297,7 +445,7 @@ const bedrockInputParser = tConversationSchema.pick({
 		delete additionalFields.reasoning_effort;
 		if (typeof reasoningEffort === "string" && bedrockReasoningConfigValues.has(reasoningEffort)) additionalFields.reasoning_config = reasoningEffort;
 	}
-	const isAnthropicModel = typeof typedData.model === "string" && typedData.model.includes("anthropic.");
+	const isAnthropicModel = typeof typedData.model === "string" && isBedrockClaudeModel(typedData.model);
 	/** Strip stale fields from previously-persisted additionalModelRequestFields */
 	if (typeof typedData.additionalModelRequestFields === "object" && typedData.additionalModelRequestFields != null) {
 		const amrf = typedData.additionalModelRequestFields;
@@ -311,6 +459,22 @@ const bedrockInputParser = tConversationSchema.pick({
 		} else {
 			delete amrf.reasoning_config;
 			delete amrf.reasoning_effort;
+			/** A Claude model that does not support Bedrock thinking (e.g. a bare
+			* `claude-3-5-sonnet` inference profile) must not carry stale thinking
+			* fields from a previously-selected thinking model. Drop only the
+			* LibreChat-generated betas (output-128k, fine-grained tool streaming);
+			* user opt-ins in `anthropic_beta` are preserved. */
+			if (!isThinkingModel) {
+				delete amrf.thinking;
+				delete amrf.thinkingBudget;
+				delete amrf.effort;
+				delete amrf.output_config;
+				if (amrf.anthropic_beta !== void 0) {
+					const kept = normalizeBetaHeaders(amrf.anthropic_beta).filter((header) => !GENERATED_BEDROCK_BETAS.has(header));
+					if (kept.length > 0) amrf.anthropic_beta = kept;
+					else delete amrf.anthropic_beta;
+				}
+			}
 		}
 		if (shouldOmitSamplingParameters) {
 			delete amrf.temperature;
@@ -353,11 +517,37 @@ const bedrockInputParser = tConversationSchema.pick({
 * @param data - The parsed Bedrock request options object
 * @returns The object with thinking configured appropriately
 */
+/**
+* `anthropicSettings.maxOutputTokens.reset` only matches the canonical
+* family-first id (`claude-sonnet-5`); Bedrock also accepts number-first
+* aliases (`claude-5-sonnet`, `claude-4-7-sonnet`) that this file gates as
+* thinking models. Canonicalize to family-first so those aliases resolve to the
+* real ceiling instead of the 8192 fallback.
+*/
+function toFamilyFirstClaudeId(model) {
+	return model.replace(/claude-(\d+(?:[-.]\d+)?)-(sonnet|opus|haiku)/, "claude-$2-$1");
+}
+function isBedrockClaudeSonnet46(model) {
+	return /claude-sonnet[-.]?4[-.]?6(?=$|[^0-9])/.test(toFamilyFirstClaudeId(model));
+}
+/**
+* Thinking tokens share the `maxTokens` output budget with tool-call arguments
+* (e.g. a `create_file` `content`), so a low default truncates large authored
+* files mid-argument. Mirror the direct-Anthropic path and default to the
+* model's full max output when the request does not set one explicitly.
+*/
+function resolveThinkingMaxTokens(data) {
+	const explicit = data.maxTokens ?? data.maxOutputTokens;
+	if (typeof explicit === "number" && explicit > 0) return explicit;
+	const model = typeof data.model === "string" ? data.model : "";
+	if (isBedrockClaudeSonnet46(model)) return BEDROCK_CLAUDE_SONNET_4_6_MAX_OUTPUT;
+	return anthropicSettings.maxOutputTokens.reset(toFamilyFirstClaudeId(model));
+}
 function configureThinking(data) {
 	const updatedData = { ...data };
 	const thinking = updatedData.additionalModelRequestFields?.thinking;
 	if (thinking === true) {
-		updatedData.maxTokens = updatedData.maxTokens ?? updatedData.maxOutputTokens ?? DEFAULT_ENABLED_MAX_TOKENS;
+		updatedData.maxTokens = resolveThinkingMaxTokens(updatedData);
 		delete updatedData.maxOutputTokens;
 		const thinkingConfig = {
 			type: "enabled",
@@ -367,12 +557,30 @@ function configureThinking(data) {
 		updatedData.additionalModelRequestFields.thinking = thinkingConfig;
 		delete updatedData.additionalModelRequestFields.thinkingBudget;
 	} else if (typeof thinking === "object" && thinking != null && thinking.type === "adaptive") {
-		if (updatedData.maxTokens == null && updatedData.maxOutputTokens != null) updatedData.maxTokens = updatedData.maxOutputTokens;
+		updatedData.maxTokens = resolveThinkingMaxTokens(updatedData);
 		delete updatedData.maxOutputTokens;
 		delete updatedData.additionalModelRequestFields.thinkingBudget;
 	}
 	return updatedData;
 }
+/** Top-level Converse request fields (issue #14029: `system` from a preset).
+*  The input parser's catch-all routes unknown keys into
+*  additionalModelRequestFields, and Bedrock rejects any that collide with a
+*  field the request already sends (`messages`/`modelId` always,
+*  `inferenceConfig` whenever maxTokens is set, `toolConfig` for agents). */
+const RESERVED_CONVERSE_FIELDS = [
+	"system",
+	"messages",
+	"modelId",
+	"toolConfig",
+	"inferenceConfig",
+	"guardrailConfig",
+	"promptVariables",
+	"requestMetadata",
+	"performanceConfig",
+	"additionalModelRequestFields",
+	"additionalModelResponseFieldPaths"
+];
 const bedrockOutputParser = (data) => {
 	const knownKeys = [
 		...Object.keys(tConversationSchema.shape),
@@ -391,7 +599,15 @@ const bedrockOutputParser = (data) => {
 	if (result.maxTokens !== void 0 && result.maxOutputTokens === void 0) result.maxOutputTokens = result.maxTokens;
 	else if (result.maxOutputTokens !== void 0 && result.maxTokens === void 0) result.maxTokens = result.maxOutputTokens;
 	result = configureThinking(result);
-	const amrf = result.additionalModelRequestFields;
+	let amrf = result.additionalModelRequestFields;
+	if (amrf && typeof amrf === "object") {
+		const reserved = RESERVED_CONVERSE_FIELDS.filter((key) => key in (amrf ?? {}));
+		if (reserved.length > 0) {
+			amrf = { ...amrf };
+			for (const key of reserved) delete amrf[key];
+			result.additionalModelRequestFields = amrf;
+		}
+	}
 	if (!amrf || Object.keys(amrf).length === 0) delete result.additionalModelRequestFields;
 	return result;
 };
@@ -408,6 +624,8 @@ let ContentTypes = /* @__PURE__ */ function(ContentTypes) {
 	ContentTypes["INPUT_AUDIO"] = "input_audio";
 	ContentTypes["AGENT_UPDATE"] = "agent_update";
 	ContentTypes["SUMMARY"] = "summary";
+	ContentTypes["ACTIVITY_LABEL"] = "activity_label";
+	ContentTypes["STEER"] = "steer";
 	ContentTypes["ERROR"] = "error";
 	return ContentTypes;
 }({});
@@ -432,10 +650,14 @@ let StepEvents = /* @__PURE__ */ function(StepEvents) {
 	StepEvents["ON_REASONING_DELTA"] = "on_reasoning_delta";
 	StepEvents["ON_RUN_STEP_DELTA"] = "on_run_step_delta";
 	StepEvents["ON_RUN_STEP_COMPLETED"] = "on_run_step_completed";
+	/** Terminal signal for a run step: closed with a status and timestamps. */
+	StepEvents["ON_RUN_STEP_CLOSED"] = "on_run_step_closed";
 	StepEvents["ON_SUMMARIZE_START"] = "on_summarize_start";
 	StepEvents["ON_SUMMARIZE_DELTA"] = "on_summarize_delta";
 	StepEvents["ON_SUMMARIZE_COMPLETE"] = "on_summarize_complete";
 	StepEvents["ON_SUBAGENT_UPDATE"] = "on_subagent_update";
+	StepEvents["ON_SANDBOX_STARTING"] = "on_sandbox_starting";
+	StepEvents["ON_PTC_TOOL_CALL"] = "on_ptc_tool_call";
 	return StepEvents;
 }({});
 /** Token-tracking event names streamed to the client (separate from StepEvents dispatch). */
@@ -445,6 +667,45 @@ let UsageEvents = /* @__PURE__ */ function(UsageEvents) {
 	return UsageEvents;
 }({});
 /**
+* Human-in-the-loop event names. Streamed to live clients when a run pauses for
+* tool approval (or an ask-user question). Reconnecting clients instead read the
+* same record from `resumeState.pendingAction` on the sync event / status route.
+*/
+let ApprovalEvents = /* @__PURE__ */ function(ApprovalEvents) {
+	ApprovalEvents["ON_PENDING_ACTION"] = "on_pending_action";
+	return ApprovalEvents;
+}({});
+/**
+* Steering event names. `on_steer_applied` streams to live clients when a
+* queued steer message is injected at a tool-batch boundary; reconnecting
+* clients recover injected steers from `aggregatedContent` and still-queued
+* ones from `resumeState.pendingSteers`. Steers that never reach a boundary
+* ride the final/abort events as `pendingSteers`.
+*/
+let SteerEvents = /* @__PURE__ */ function(SteerEvents) {
+	SteerEvents["ON_STEER_APPLIED"] = "on_steer_applied";
+	/** Durable capability correction for queued steers after HITL handover. */
+	SteerEvents["ON_STEER_UPDATED"] = "on_steer_updated";
+	return SteerEvents;
+}({});
+/**
+* Activity-label event names. `on_activity_label` streams to live clients
+* when a tool-batch or parent-phase label part is claimed and again when the
+* fast-model label resolves; reconnecting clients recover applied labels
+* from `aggregatedContent` like any other content part.
+*/
+let ActivityLabelEvents = /* @__PURE__ */ function(ActivityLabelEvents) {
+	ActivityLabelEvents["ON_ACTIVITY_LABEL"] = "on_activity_label";
+	return ActivityLabelEvents;
+}({});
+/** Live title updates for an existing reasoning content part. */
+let ReasoningLabelEvents = /* @__PURE__ */ function(ReasoningLabelEvents) {
+	ReasoningLabelEvents["ON_REASONING_LABEL"] = "on_reasoning_label";
+	/** Internal durable budget reservation; clients intentionally do not render it. */
+	ReasoningLabelEvents["ON_REASONING_LABEL_ATTEMPT"] = "on_reasoning_label_attempt";
+	return ReasoningLabelEvents;
+}({});
+/**
 * Full prompt token count for one completed model call — the EXACT context the
 * model saw, provider-aware: additive providers (Bedrock) report `input_tokens`
 * excluding cache, so cache reads/writes are added back; subset providers
@@ -651,19 +912,21 @@ const parseCompactConvo = ({ endpoint, endpointType, conversation, possibleValue
 	if (models && convo) convo.model = getFirstDefinedValue(models) ?? convo.model;
 	return convo;
 };
-function parseTextParts(contentParts, skipReasoning = false) {
+function parseTextParts(contentParts, skipReasoning = false, options) {
 	let result = "";
+	const append = (textValue) => {
+		if (result.length > 0 && textValue.length > 0 && result[result.length - 1] !== " " && textValue[0] !== " ") result += " ";
+		result += textValue;
+	};
 	for (const part of contentParts) {
 		if (!part?.type) continue;
-		if (part.type === "text") {
-			const textValue = (typeof part.text === "string" ? part.text : part.text?.value) || "";
-			if (result.length > 0 && textValue.length > 0 && result[result.length - 1] !== " " && textValue[0] !== " ") result += " ";
-			result += textValue;
-		} else if (part.type === "think" && !skipReasoning) {
-			const textValue = typeof part.think === "string" ? part.think : "";
-			if (result.length > 0 && textValue.length > 0 && result[result.length - 1] !== " " && textValue[0] !== " ") result += " ";
-			result += textValue;
-		}
+		if (part.type === "text") append((typeof part.text === "string" ? part.text : part.text?.value) || "");
+		else if (part.type === "steer" && options?.includeSteer === true)
+ /** Mid-run user speech: excluded by default so generic extraction (TTS
+		*  reading assistant output) never speaks the user's own words — the
+		*  full-record surfaces (search indexing, persisted abort text) opt in. */
+		append(typeof part.steer === "string" ? part.steer : "");
+		else if (part.type === "think" && !skipReasoning) append(typeof part.think === "string" ? part.think : "");
 	}
 	return result;
 }
@@ -717,6 +980,14 @@ function replaceSpecialVars({ text, user, now: inputNow, timezone }) {
 	return result;
 }
 /**
+* Resolves the display label ("sender") for an ephemeral agent:
+* `modelLabel` (user/preset) → model spec's `label` → endpoint config's
+* `modelDisplayLabel` → `''` (lets consumers fall back to the model name).
+*/
+function getEphemeralSender({ modelLabel, specLabel, modelDisplayLabel }) {
+	return modelLabel ?? specLabel ?? modelDisplayLabel ?? "";
+}
+/**
 * Encodes an ephemeral agent ID from endpoint, model, optional sender, and optional index.
 * Uses __ to replace : (reserved in graph node names) and ___ to separate sender.
 *
@@ -1008,15 +1279,132 @@ function mapGroupToAzureConfig({ groupName, groupMap }) {
 	return result;
 }
 //#endregion
+//#region src/langchain.ts
+/**
+* LangChain classifies a provider failure by mutating the error: it stamps `lc_error_code` and
+* appends `\n\nTroubleshooting URL: <docs url>\n` to the message. Both halves are handled here
+* because the server strips the URL before persisting the message, while the client still reads the
+* code back out of messages persisted before it did.
+*/
+const LANGCHAIN = "langchain";
+const ERROR_PATH = "/errors/";
+const TROUBLESHOOTING_LABEL = "Troubleshooting URL:";
+const WHITESPACE = /\s/;
+/** Provider errors cross untyped boundaries, so a `message` is not guaranteed to be a string. */
+function toMessageText(message) {
+	if (typeof message === "string") return message;
+	return message == null ? "" : String(message);
+}
+function isErrorCodeCharacter(character) {
+	const code = character.charCodeAt(0);
+	return character === "_" || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function findTokenEnd(text, start, limit = text.length) {
+	let end = start;
+	while (end < limit && !WHITESPACE.test(text[end])) end += 1;
+	return end;
+}
+function findErrorCode(text, searchableText, start, end) {
+	const langChainIndex = searchableText.indexOf(LANGCHAIN, start);
+	if (langChainIndex < 0 || langChainIndex >= end) return;
+	let errorCode;
+	let pathIndex = searchableText.indexOf(ERROR_PATH, langChainIndex + 9);
+	while (pathIndex >= 0 && pathIndex < end) {
+		const codeStart = pathIndex + 8;
+		let codeEnd = codeStart;
+		while (codeEnd < end && isErrorCodeCharacter(text[codeEnd])) codeEnd += 1;
+		if (codeEnd > codeStart) errorCode = {
+			start: codeStart,
+			end: codeEnd
+		};
+		pathIndex = searchableText.indexOf(ERROR_PATH, Math.max(codeStart, codeEnd));
+	}
+	return errorCode;
+}
+/** Removes LangChain's appended docs URL so provider text carries no third-party attribution. */
+function stripLangChainTroubleshootingUrl(message) {
+	const text = toMessageText(message);
+	const parts = [];
+	let copiedUntil = 0;
+	let searchFrom = 0;
+	while (searchFrom < text.length) {
+		const labelStart = text.indexOf(TROUBLESHOOTING_LABEL, searchFrom);
+		if (labelStart < 0) break;
+		let matchStart = labelStart;
+		while (matchStart > copiedUntil && WHITESPACE.test(text[matchStart - 1])) matchStart -= 1;
+		let urlStart = labelStart + 20;
+		while (urlStart < text.length && WHITESPACE.test(text[urlStart])) urlStart += 1;
+		if (!text.startsWith("https://", urlStart) && !text.startsWith("http://", urlStart)) {
+			searchFrom = urlStart;
+			continue;
+		}
+		const urlEnd = findTokenEnd(text, urlStart);
+		const errorCode = findErrorCode(text, text, urlStart, urlEnd);
+		if (errorCode == null) {
+			searchFrom = urlEnd;
+			continue;
+		}
+		let matchEnd = errorCode.end;
+		if (text[matchEnd] === "/") matchEnd += 1;
+		while (matchEnd < text.length && WHITESPACE.test(text[matchEnd])) matchEnd += 1;
+		parts.push(text.slice(copiedUntil, matchStart), " ");
+		copiedUntil = matchEnd;
+		searchFrom = matchEnd;
+	}
+	parts.push(text.slice(copiedUntil));
+	return parts.join("").trim();
+}
+/** The classification LangChain encoded in the docs URL it appended, when the text carries one. */
+function parseLangChainErrorCode(message) {
+	const text = toMessageText(message);
+	const searchableText = text.toLowerCase();
+	let searchFrom = 0;
+	while (searchFrom < text.length) {
+		const langChainIndex = searchableText.indexOf(LANGCHAIN, searchFrom);
+		if (langChainIndex < 0) return;
+		const tokenEnd = findTokenEnd(text, langChainIndex);
+		const errorCode = findErrorCode(text, searchableText, langChainIndex, tokenEnd);
+		if (errorCode != null) return text.slice(errorCode.start, errorCode.end).toUpperCase();
+		searchFrom = tokenEnd + 1;
+	}
+}
+//#endregion
 //#region src/messages.ts
+/** A generated reasoning title describes the text as it existed at generation time.
+*  Any manual edit or merge into a different reasoning step invalidates the entire
+*  title revision domain while preserving unrelated content metadata. */
+function stripReasoningLabelMetadata(part) {
+	if (part.type !== "think") return part;
+	const { reasoning_label: _label, reasoning_label_step_id: _stepId, reasoning_label_attempts: _attempts, reasoning_label_submitted_chars: _submittedChars, reasoning_label_revision: _revision, reasoning_label_status: _status, ...unlabeledPart } = part;
+	return unlabeledPart;
+}
+const treeCache = /* @__PURE__ */ new WeakMap();
+/**
+* Builds the render tree from the flat messages array. Order-robust: live
+* stream/steer/preempt cache writes can momentarily place a child before its
+* parent, and a single-pass link would hoist such rows into phantom root
+* branches — folding the visible thread to one dangling branch until a
+* refetch restores creation order. Linking happens only after every message
+* is indexed, so array order never changes the tree shape.
+*/
 function buildTree({ messages, fileMap }) {
 	if (messages === null) return null;
+	const cached = treeCache.get(messages);
+	if (cached) {
+		if (fileMap == null && cached.bare) return cached.bare;
+		if (fileMap != null && cached.fileMap === fileMap && cached.hydrated) return cached.hydrated;
+	}
 	const messageMap = {};
+	const orderedMessages = [];
 	const rootMessages = [];
 	const childrenCount = {};
-	messages.forEach((message) => {
-		if (!message) return;
-		const parentId = message.parentMessageId ?? "";
+	for (const message of messages) {
+		if (!message) continue;
+		/** A self-parented row can never link under itself (it becomes a root),
+		*  so count it with the parentless group — charging its own id would
+		*  inflate the sibling indices of its real children past
+		*  `children.length`. */
+		const parentId = message.parentMessageId === message.messageId ? "" : message.parentMessageId ?? "";
 		childrenCount[parentId] = (childrenCount[parentId] || 0) + 1;
 		const extendedMessage = {
 			...message,
@@ -1026,13 +1414,102 @@ function buildTree({ messages, fileMap }) {
 		};
 		if (message.files && fileMap) extendedMessage.files = message.files.map((file) => fileMap[file.file_id ?? ""] ?? file);
 		messageMap[message.messageId] = extendedMessage;
-		const parentMessage = messageMap[parentId];
-		if (parentMessage) {
-			parentMessage.children.push(extendedMessage);
-			extendedMessage.depth = parentMessage.depth + 1;
-		} else rootMessages.push(extendedMessage);
-	});
-	return rootMessages;
+		orderedMessages.push(extendedMessage);
+	}
+	for (const extendedMessage of orderedMessages) {
+		const parentMessage = messageMap[extendedMessage.parentMessageId ?? ""];
+		if (parentMessage && parentMessage !== extendedMessage) parentMessage.children.push(extendedMessage);
+		else rootMessages.push(extendedMessage);
+	}
+	/** Depth comes from a roots-down walk (a child linked before its parent
+	*  can't inherit depth at link time). The `visited` set doubles as the
+	*  cycle guard: nodes on a corrupt parent cycle are unreachable from any
+	*  root, so they resurface as roots instead of disappearing. */
+	const visited = /* @__PURE__ */ new Set();
+	const assignDepths = (root) => {
+		visited.add(root);
+		const stack = [root];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			/** Every node has one parent, so this walk reaches each node once — an
+			*  already-visited child is a cycle back-edge. Sever it (not just skip
+			*  it) so consumers that recurse `children` terminate. */
+			if (node.children.some((child) => visited.has(child))) node.children = node.children.filter((child) => !visited.has(child));
+			for (const child of node.children) {
+				child.depth = node.depth + 1;
+				visited.add(child);
+				stack.push(child);
+			}
+		}
+	};
+	for (const root of rootMessages) assignDepths(root);
+	for (const extendedMessage of orderedMessages) if (!visited.has(extendedMessage)) {
+		rootMessages.push(extendedMessage);
+		assignDepths(extendedMessage);
+	}
+	const tree = rootMessages;
+	const entry = cached ?? {};
+	if (fileMap == null) entry.bare = tree;
+	else {
+		entry.fileMap = fileMap;
+		entry.hydrated = tree;
+	}
+	if (!cached) treeCache.set(messages, entry);
+	return tree;
+}
+//#endregion
+//#region src/runSteps.ts
+/**
+* Below this, a duration is noise rather than information: sub-second tool
+* calls are the common case, and labelling every one of them `· 0.3s` adds a
+* moving number to the end of most cards without telling the reader anything
+* they could act on. Callers use {@link isReportableRunStepDuration} rather
+* than comparing against this directly.
+*/
+const MIN_REPORTABLE_RUN_STEP_DURATION_MS = 1e3;
+/**
+* Wall-clock duration of a run step, derived from the terminal
+* `on_run_step_closed` event.
+*
+* Returns `undefined` rather than a fallback whenever the value would be a
+* guess, because a wrong duration is worse than an absent one — an absent one
+* renders nothing, a wrong one is indistinguishable from a real measurement:
+*
+* - `created_at` is optional on the event; emitters that do not know when the
+*   step opened cannot have their duration inferred from anything else.
+* - A negative result means the two timestamps came from clocks that disagree.
+*   That is not hypothetical: since `@librechat/agents` v3.6.0 a step can be
+*   opened in one process and closed in another after a checkpoint resume, so
+*   the two stamps can legitimately originate on different machines.
+* - Non-finite input is treated as absent instead of propagating `NaN` into
+*   rendering.
+*
+* Known limits, accepted rather than guessed at: only the negative direction
+* of clock skew is detectable from a single stamp pair — positive skew
+* inflates the result and cannot be distinguished from a genuinely long
+* step. And the value is wall-clock elapsed between open and close, so a
+* step held open across a suspension (a checkpoint resume, a HITL approval
+* wait) includes that held-open time. Both are properties of the only data
+* available, not derivation bugs.
+*/
+function getRunStepDurationMs(closed) {
+	const { created_at: createdAt, closed_at: closedAt } = closed;
+	if (typeof createdAt !== "number" || typeof closedAt !== "number") return;
+	if (!Number.isFinite(createdAt) || !Number.isFinite(closedAt)) return;
+	const durationMs = closedAt - createdAt;
+	return durationMs >= 0 ? durationMs : void 0;
+}
+/**
+* Whether a derived duration is worth showing to the reader.
+*
+* This is a presentation judgment, so it belongs at render time only. The
+* stamp sites persist the raw {@link getRunStepDurationMs} value instead of
+* pre-filtering through this — thresholding at write time would bake a
+* display rule into stored data, making "fast" indistinguishable from "not
+* derivable" and unrecoverable if the rule ever changes.
+*/
+function isReportableRunStepDuration(durationMs) {
+	return typeof durationMs === "number" && durationMs >= 1e3;
 }
 //#endregion
 //#region src/artifacts.ts
@@ -4205,6 +4682,10 @@ let PermissionTypes = /* @__PURE__ */ function(PermissionTypes) {
 	* Type for Shared Link Permissions
 	*/
 	PermissionTypes["SHARED_LINKS"] = "SHARED_LINKS";
+	/**
+	* Type for Scheduled Chats Permissions
+	*/
+	PermissionTypes["SCHEDULES"] = "SCHEDULES";
 	return PermissionTypes;
 }({});
 /**
@@ -4228,11 +4709,20 @@ const PERMISSION_TYPE_INTERFACE_FIELDS = {
 	["MCP_SERVERS"]: "mcpServers",
 	["REMOTE_AGENTS"]: "remoteAgents",
 	["SKILLS"]: "skills",
-	["SHARED_LINKS"]: "sharedLinks"
+	["SHARED_LINKS"]: "sharedLinks",
+	["SCHEDULES"]: "schedules"
 };
 /** Set of interface config field names that correspond to role permissions. */
 const INTERFACE_PERMISSION_FIELDS = new Set(Object.values(PERMISSION_TYPE_INTERFACE_FIELDS));
 /**
+* Interface fields that seed a permission (use/create) BUT also carry runtime
+* config that must survive DB/tenant/user overrides. For these, override
+* sanitizers strip only the permission sub-keys (use/create) from the object
+* form and PRESERVE the boolean form — for `schedules`, `interface.schedules: false`
+* is the runtime feature disable that `getLimits` reads, not a permission toggle.
+*/
+const RUNTIME_CONFIG_INTERFACE_FIELDS = new Set(["schedules"]);
+/**
 * YAML sub-keys within composite interface permission fields that map to permission bits.
 * When an interface permission field is an object, only these sub-keys are stripped from
 * DB overrides — other sub-keys (like `placeholder`, `trustCheckbox`) are UI-only and pass through.
@@ -4333,6 +4823,10 @@ const skillPermissionsSchema = z.object({
 	["SHARE"]: z.boolean().default(false),
 	["SHARE_PUBLIC"]: z.boolean().default(false)
 });
+const schedulesPermissionsSchema = z.object({
+	["USE"]: z.boolean().default(true),
+	["CREATE"]: z.boolean().default(true)
+});
 const sharedLinksPermissionsSchema = z.object({
 	["CREATE"]: z.boolean().default(true),
 	["SHARE"]: z.boolean().default(true),
@@ -4354,7 +4848,8 @@ const permissionsSchema = z.object({
 	["MCP_SERVERS"]: mcpServersPermissionsSchema,
 	["REMOTE_AGENTS"]: remoteAgentsPermissionsSchema,
 	["SKILLS"]: skillPermissionsSchema,
-	["SHARED_LINKS"]: sharedLinksPermissionsSchema
+	["SHARED_LINKS"]: sharedLinksPermissionsSchema,
+	["SCHEDULES"]: schedulesPermissionsSchema
 });
 //#endregion
 //#region src/roles.ts
@@ -4435,6 +4930,10 @@ const defaultRolesSchema = z.object({
 				["CREATE"]: z.boolean().default(true),
 				["SHARE"]: z.boolean().default(true),
 				["SHARE_PUBLIC"]: z.boolean().default(true)
+			}),
+			["SCHEDULES"]: schedulesPermissionsSchema.extend({
+				["USE"]: z.boolean().default(true),
+				["CREATE"]: z.boolean().default(true)
 			})
 		})
 	}),
@@ -4508,6 +5007,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	},
@@ -4563,6 +5066,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	}
@@ -4582,6 +5089,308 @@ let InvocationMode = /* @__PURE__ */ function(InvocationMode) {
 	return InvocationMode;
 }({});
 //#endregion
+//#region src/types/schedules.ts
+/** Cadences the dialog builds from structured pickers (hour, minute, weekday). */
+const scheduleStructuredFrequencies = [
+	"hourly",
+	"daily",
+	"weekdays",
+	"weekly"
+];
+const scheduleFrequencies = [...scheduleStructuredFrequencies, "cron"];
+/** Bounds a stored expression. Generous for five fields, because each one can hold a
+*  list: an every-minute-of-the-hour cadence spelled out runs past two hundred chars. */
+const SCHEDULE_CRON_MAX_LENGTH = 256;
+const scheduleTargets = ["new"];
+const structuredCadenceSchema = z.object({
+	frequency: z.enum(scheduleStructuredFrequencies),
+	hour: z.number().int().min(0).max(23),
+	minute: z.number().int().min(0).max(59),
+	daysOfWeek: z.array(z.number().int().min(0).max(6)).min(1).max(7).transform((days) => Array.from(new Set(days))).optional()
+});
+/**
+* A raw cron expression carries its own hour and minute, so it cannot share the
+* structured shape: there is no single `hour` for `0 9,17 * * 1-5`. Syntax is
+* validated server-side by croner, the same parser the engine fires from, rather
+* than by a regex that would accept patterns croner then rejects at fire time.
+*/
+const cronCadenceSchema = z.object({
+	frequency: z.literal("cron"),
+	expression: z.string().trim().min(1).max(256)
+});
+const scheduleCadenceSchema = z.discriminatedUnion("frequency", [structuredCadenceSchema, cronCadenceSchema]);
+const isCronCadence = (cadence) => cadence.frequency === "cron";
+const createSchedulePayloadSchema = z.object({
+	name: z.string().trim().min(1).max(256),
+	prompt: z.string().trim().min(1).max(32e3),
+	agent_id: z.string().trim().min(1),
+	cadence: scheduleCadenceSchema,
+	timezone: z.string().min(1),
+	target: z.enum(scheduleTargets).default("new"),
+	file_ids: z.array(z.string()).max(10).transform((ids) => Array.from(new Set(ids))).optional(),
+	/**
+	* Chat project each run's conversation is filed under. `null` clears the scope.
+	* Ownership is checked server-side at write time and again at every fire, so a
+	* deleted project disables the schedule instead of silently filing runs loose.
+	*/
+	chatProjectId: z.string().trim().min(1).nullable().optional(),
+	enabled: z.boolean().default(true),
+	/**
+	* Client-generated key making creation idempotent across retries. Creation commits
+	* the row and arms it in two writes, so a failure between them leaves the client
+	* unable to tell whether anything persisted; retrying blind can produce two recurring
+	* schedules. A retry carrying the same key resolves to the original row instead.
+	* REQUIRED: an optional key preserves the keyless duplicate path for any client
+	* that omits it, which is exactly the failure the key exists to close.
+	*/
+	clientRequestId: z.string().trim().min(1).max(128)
+});
+/** Idempotency is a property of the CREATE attempt, not of the schedule's config. */
+const updateSchedulePayloadSchema = createSchedulePayloadSchema.omit({ clientRequestId: true }).partial().extend({ 
+/**
+* The configRevision the client's edit was computed from (captured when the
+* dialog opened). The server fences the update on it, so a concurrent edit
+* from another tab answers 409 instead of being silently overwritten by a
+* payload rebuilt from a stale snapshot (cadence is sent whole, so the
+* server-side fresh-read fence alone cannot detect this).
+*/
+expectedConfigRevision: z.number().int().min(0).optional() });
+//#endregion
+//#region src/cadence.ts
+/** Mirrors the server default when a weekly cadence omits `daysOfWeek`. */
+const WEEKLY_DEFAULT_DAY = 1;
+/**
+* Minute, hour, day of month, month, day of week. croner also reads a six-field form
+* carrying seconds and a seven-field form that pins a year, and both are refused.
+* Seconds would promise a precision the runtime does not keep: the engine polls on a
+* thirty-second tick and offsets each schedule by up to two minutes of jitter. A pinned
+* year makes a cadence that runs out, and every caller here treats "no next occurrence"
+* as a cadence it cannot read.
+*/
+const CRON_FIELD_COUNT = 5;
+/**
+* Spring-forward compresses consecutive wall-clock occurrences, so the ENFORCEABLE
+* minimum for day-and-longer gaps is the nominal gap minus the largest real-world
+* transition: two hours (Antarctica/Troll; every other zone shifts at most one).
+* A floor set exactly at the nominal value would otherwise admit a schedule that
+* genuinely violates it once a year. Hourly gaps are unaffected (the skipped hours
+* lengthen, never shorten, the gap between occurrences).
+*/
+const DST_COMPRESSION_MINUTES = 120;
+/**
+* Occurrences sampled when measuring a cron expression's tightest gap. The floor
+* exists to reject expressions that fire too OFTEN, and a dense pattern reveals
+* its short gap within the first few occurrences, so a small window answers the
+* question this guards. Known limit: this is a bounded probe, not the exhaustive
+* proof the structured formulas give. An expression that is sparse for the next
+* `CRON_PROBE_OCCURRENCES` runs and dense later would pass here and be caught by
+* the fire-time recheck instead.
+*/
+const CRON_PROBE_OCCURRENCES = 32;
+/** Enough to span four nominal gaps from an anchor two gaps before a transition,
+*  which is what guarantees the straddling pair falls inside the window. */
+const TRANSITION_PROBE_OCCURRENCES = 5;
+/**
+* Compiles a cadence to the cron expression the engine fires from. Shared rather
+* than server-owned because the dialog previews the next runs, validates the
+* interval floor, and disables its own submit from these same functions: a second
+* client-side implementation would drift and either show run times the schedule
+* does not keep or accept a cadence the server then rejects.
+*/
+function cadenceToCron(cadence) {
+	if (cadence.frequency === "cron") return cadence.expression;
+	const { frequency, hour, minute } = cadence;
+	if (frequency === "hourly") return `${minute} * * * *`;
+	if (frequency === "daily") return `${minute} ${hour} * * *`;
+	if (frequency === "weekdays") return `${minute} ${hour} * * 1-5`;
+	return `${minute} ${hour} * * ${[...cadence.daysOfWeek?.length ? cadence.daysOfWeek : [WEEKLY_DEFAULT_DAY]].sort((a, b) => a - b).join(",")}`;
+}
+/**
+* Everything `cronCadenceSchema` will accept: exactly five fields, within the length
+* the schema stores, and actually matching at some point. croner accepts syntactically
+* valid patterns that can never match (`0 0 30 2 *`), and those would arm a schedule
+* that never fires. Validated with croner rather than a regex, because a regex would
+* accept patterns croner then rejects at fire time.
+*
+* A five-field expression that matches at all matches forever, which is what lets every
+* caller keep reading "no next occurrence" as "this cadence is unreadable".
+*/
+function isValidCronExpression(expression, timezone) {
+	const trimmed = expression.trim();
+	if (trimmed.length > 256) return false;
+	if (trimmed.split(/\s+/).length !== CRON_FIELD_COUNT) return false;
+	try {
+		return new Cron(trimmed, {
+			timezone,
+			paused: true
+		}).nextRun() != null;
+	} catch {
+		return false;
+	}
+}
+/**
+* The next occurrences the engine would fire. Server-side jitter (up to two
+* minutes) is deliberately not modelled: it is keyed off a schedule id that does
+* not exist yet at create time, and showing 9:01 for a 9:00 schedule reads as a bug.
+*/
+function nextRunInstants(cadence, timezone, count) {
+	try {
+		const runs = new Cron(cadenceToCron(cadence), {
+			timezone,
+			paused: true
+		}).nextRuns(count);
+		return runs.filter((run, index) => index === 0 || run.getTime() !== runs[index - 1].getTime());
+	} catch {
+		return [];
+	}
+}
+const MINUTE_MS = 6e4;
+const DAY_MS = 1440 * MINUTE_MS;
+/** A year and a bit, so a zone with a single yearly transition always shows one. */
+const TRANSITION_SEARCH_DAYS = 400;
+const offsetFormatters = /* @__PURE__ */ new Map();
+/** Minutes east of UTC in `zone` at `instant`, read back from the wall clock the
+*  zone renders. The only way to observe a zone's offset without a tz database. */
+function zoneOffsetMinutes(zone, instant) {
+	let formatter = offsetFormatters.get(zone);
+	if (formatter == null) {
+		formatter = new Intl.DateTimeFormat("en-US", {
+			timeZone: zone,
+			hourCycle: "h23",
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit"
+		});
+		offsetFormatters.set(zone, formatter);
+	}
+	const parts = {};
+	for (const part of formatter.formatToParts(instant)) parts[part.type] = part.value;
+	const wallClock = Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day), Number(parts.hour), Number(parts.minute), Number(parts.second));
+	return Math.round((wallClock - instant.getTime()) / MINUTE_MS);
+}
+/** Zone transitions are asked for once per fire, and the scan below costs ~10ms.
+*  Keyed by day because that is how far the answer stays put as the window slides,
+*  and cleared wholesale at the cap so a long-lived worker cannot accumulate an
+*  entry per zone per day forever. */
+const transitionCache = /* @__PURE__ */ new Map();
+const TRANSITION_CACHE_MAX = 512;
+/**
+* Every instant `zone` changes its UTC offset within the search window; empty for a
+* fixed-offset zone. Both directions matter and only one of them shortens anything,
+* so taking just the next one would usually find the harmless fall-back and miss the
+* spring-forward six months behind it. Bracketed a day at a time, bisected to the
+* minute.
+*/
+function offsetChanges(zone, from) {
+	const day = Math.floor(from.getTime() / DAY_MS);
+	const cacheKey = `${zone}:${day}`;
+	const cached = transitionCache.get(cacheKey);
+	if (cached != null) return cached;
+	const changes = [];
+	const start = /* @__PURE__ */ new Date((day - 1) * DAY_MS);
+	let low = start.getTime();
+	let baseOffset = zoneOffsetMinutes(zone, start);
+	const end = low + TRANSITION_SEARCH_DAYS * DAY_MS;
+	for (let probe = low + DAY_MS; probe <= end; probe += DAY_MS) {
+		const offset = zoneOffsetMinutes(zone, new Date(probe));
+		if (offset !== baseOffset) {
+			let high = probe;
+			let bracket = low;
+			while (high - bracket > MINUTE_MS) {
+				const mid = bracket + Math.floor((high - bracket) / 2);
+				if (zoneOffsetMinutes(zone, new Date(mid)) === baseOffset) bracket = mid;
+				else high = mid;
+			}
+			changes.push(new Date(high));
+			baseOffset = offset;
+		}
+		low = probe;
+	}
+	if (transitionCache.size >= TRANSITION_CACHE_MAX) transitionCache.clear();
+	transitionCache.set(cacheKey, changes);
+	return changes;
+}
+function runsAfter(expression, from, zone, occurrences = CRON_PROBE_OCCURRENCES) {
+	return new Cron(expression, {
+		timezone: zone,
+		paused: true
+	}).nextRuns(occurrences, from);
+}
+/** Tightest gap, in minutes, across `runs`; null when there is no pair to measure. */
+function minGapMinutes(runs) {
+	if (runs.length < 2) return null;
+	let minGapMs = Number.MAX_SAFE_INTEGER;
+	for (let i = 1; i < runs.length; i++) {
+		const gapMs = runs[i].getTime() - runs[i - 1].getTime();
+		if (gapMs <= 0) continue;
+		minGapMs = Math.min(minGapMs, gapMs);
+	}
+	if (minGapMs === Number.MAX_SAFE_INTEGER) return null;
+	return Math.floor(minGapMs / MINUTE_MS);
+}
+function probeMinGapMinutes(expression, zone, from, occurrences = CRON_PROBE_OCCURRENCES) {
+	return minGapMinutes(runsAfter(expression, from, zone, occurrences));
+}
+/**
+* Smallest gap in minutes between occurrences. Returns 0 for an unparseable or
+* never-matching expression so every floor rejects it, failing closed rather than
+* admitting an expression the engine cannot fire.
+*
+* Measured twice, and the smaller wins:
+*
+* 1. Nominal, probed in UTC, then discounted by the same worst-case DST allowance
+*    the structured branches assume. This keeps `0 9 * * *` reporting exactly what
+*    the Daily preset reports, so the same schedule cannot be admitted in one form
+*    and rejected in the other.
+* 2. Real elapsed time in the schedule's own zone, across each of that zone's
+*    transitions. Spring-forward compresses a gap that straddles one
+*    (`0 0,12 * * *` in America/New_York is 11 hours that day, not 12), and step 1
+*    only discounts gaps of a day or more, so a subdaily gap needs measuring rather
+*    than estimating. Anchoring at the transition is what makes a bounded probe see
+*    it at all: from today it is usually months outside any reasonable window.
+*/
+function cronIntervalMinutes(expression, timezone) {
+	try {
+		const now = /* @__PURE__ */ new Date();
+		const nominal = probeMinGapMinutes(expression, "UTC", now);
+		if (nominal == null) return 0;
+		const estimate = nominal < 1440 ? nominal : Math.max(0, nominal - DST_COMPRESSION_MINUTES);
+		if (timezone == null || estimate === 0) return estimate;
+		const anchorBackMs = 2 * Math.max(nominal, 1) * MINUTE_MS;
+		let smallest = estimate;
+		for (const transition of offsetChanges(timezone, now)) {
+			const measured = probeMinGapMinutes(expression, timezone, new Date(Math.max(now.getTime(), transition.getTime() - anchorBackMs)), TRANSITION_PROBE_OCCURRENCES);
+			if (measured != null) smallest = Math.min(smallest, measured);
+		}
+		return smallest;
+	} catch {
+		return 0;
+	}
+}
+/**
+* Minimum minutes between occurrences, for the admin interval floor. `timezone` is
+* the schedule's own; passing it lets the cron branch measure a DST-compressed gap
+* instead of estimating one. The structured branches are zone-independent: their
+* formulas already carry the worst-case allowance.
+*/
+function cadenceIntervalMinutes(cadence, timezone) {
+	if (isCronCadence(cadence)) return cronIntervalMinutes(cadence.expression, timezone);
+	if (cadence.frequency === "hourly") return 60;
+	if (cadence.frequency === "daily" || cadence.frequency === "weekdays") return 1440 - DST_COMPRESSION_MINUTES;
+	const days = cadence.daysOfWeek?.length ? Array.from(new Set(cadence.daysOfWeek)) : [WEEKLY_DEFAULT_DAY];
+	if (days.length <= 1) return 10080 - DST_COMPRESSION_MINUTES;
+	const sorted = [...days].sort((a, b) => a - b);
+	let minGapDays = 7;
+	for (let i = 0; i < sorted.length; i++) {
+		const gap = i + 1 < sorted.length ? sorted[i + 1] - sorted[i] : 7 - sorted[i] + sorted[0];
+		minGapDays = Math.min(minGapDays, gap);
+	}
+	return minGapDays * 24 * 60 - DST_COMPRESSION_MINUTES;
+}
+//#endregion
 //#region src/types/skills.ts
 /**
 * Shared skill validation constants — the single source of truth for name,
@@ -4614,6 +5423,171 @@ let DATE_RANGE = /* @__PURE__ */ function(DATE_RANGE) {
 	return DATE_RANGE;
 }({});
 //#endregion
+//#region src/types/insights.ts
+const INSIGHTS_MAX_RANGE_DAYS = 30;
+const INSIGHTS_SEARCH_MIN_LENGTH = 3;
+const INSIGHTS_SEARCH_MAX_LENGTH = 200;
+//#endregion
+//#region src/types/queuedTurns.ts
+const agentQueuedTurnStatuses = [
+	"queued",
+	"claimed",
+	"admitted",
+	"cancelled",
+	"dead"
+];
+const agentQueuedTurnDurability = ["process_local", "durable"];
+const agentQueuedTurnFileRefSchema = z.object({
+	file_id: z.string().trim().min(1),
+	type: z.string().optional(),
+	filepath: z.string().optional(),
+	filename: z.string().optional(),
+	height: z.number().optional(),
+	width: z.number().optional(),
+	bytes: z.number().nonnegative().optional()
+});
+const enqueueAgentQueuedTurnSchema = z.object({
+	conversationId: z.string().trim().min(1),
+	parentMessageId: z.string().trim().min(1),
+	clientRequestId: z.string().trim().min(1).max(128),
+	text: z.string(),
+	files: z.array(agentQueuedTurnFileRefSchema).optional(),
+	quotes: z.array(z.string()).optional(),
+	manualSkills: z.array(z.string().trim().min(1)).optional(),
+	priority: z.boolean().optional(),
+	expectedPredecessorCreatedAt: z.number().int().nonnegative().optional()
+});
+const listAgentQueuedTurnsSchema = z.object({
+	conversationId: z.string().trim().min(1),
+	clientRequestIds: z.array(z.string().trim().min(1).max(128)).max(100).transform((ids) => Array.from(new Set(ids))).optional()
+});
+const cancelAgentQueuedTurnSchema = z.object({ queuedTurnId: z.string().trim().min(1) });
+const agentQueuedTurnReceiptSchema = enqueueAgentQueuedTurnSchema.extend({
+	queuedTurnId: z.string().trim().min(1),
+	status: z.enum(agentQueuedTurnStatuses),
+	/** Effective generation boundary consumed by an admitted turn. This can
+	* advance beyond the originally captured root as queued turns chain. */
+	effectivePredecessorCreatedAt: z.number().int().nonnegative().optional(),
+	/** Explicitly proves that this admission consumed no predecessor boundary. */
+	rootPredecessor: z.literal(true).optional(),
+	position: z.number().int().nonnegative().optional(),
+	/** Immutable queue sequence retained as `revision` for wire compatibility. */
+	revision: z.number().int().nonnegative(),
+	failure: z.object({
+		code: z.string().trim().min(1).max(128),
+		message: z.string().max(2048).optional()
+	}).optional(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+const agentQueuedTurnCapabilitySchema = z.discriminatedUnion("supported", [z.object({ supported: z.literal(false) }), z.object({
+	supported: z.literal(true),
+	durability: z.enum(agentQueuedTurnDurability)
+})]);
+const enqueueAgentQueuedTurnResponseSchema = z.object({
+	receipt: agentQueuedTurnReceiptSchema,
+	capability: agentQueuedTurnCapabilitySchema
+});
+const listAgentQueuedTurnsResponseSchema = z.object({
+	queuedTurns: z.array(agentQueuedTurnReceiptSchema),
+	capability: agentQueuedTurnCapabilitySchema,
+	revision: z.number().int().nonnegative()
+});
+const cancelAgentQueuedTurnResponseSchema = z.object({ receipt: agentQueuedTurnReceiptSchema });
+//#endregion
+//#region src/providers.ts
+/** Canonical provider identity used for branding across client and server. */
+let ProviderId = /* @__PURE__ */ function(ProviderId) {
+	ProviderId["openai"] = "openai";
+	ProviderId["anthropic"] = "anthropic";
+	ProviderId["google"] = "google";
+	ProviderId["azure"] = "azure";
+	ProviderId["bedrock"] = "bedrock";
+	ProviderId["xai"] = "xai";
+	ProviderId["moonshot"] = "moonshot";
+	ProviderId["anyscale"] = "anyscale";
+	ProviderId["apipie"] = "apipie";
+	ProviderId["cohere"] = "cohere";
+	ProviderId["deepseek"] = "deepseek";
+	ProviderId["fireworks"] = "fireworks";
+	ProviderId["groq"] = "groq";
+	ProviderId["helicone"] = "helicone";
+	ProviderId["huggingface"] = "huggingface";
+	ProviderId["mistral"] = "mistral";
+	ProviderId["mlx"] = "mlx";
+	ProviderId["ollama"] = "ollama";
+	ProviderId["openrouter"] = "openrouter";
+	ProviderId["perplexity"] = "perplexity";
+	ProviderId["qwen"] = "qwen";
+	ProviderId["shuttleai"] = "shuttleai";
+	ProviderId["together"] = "together";
+	ProviderId["unify"] = "unify";
+	ProviderId["vercel"] = "vercel";
+	return ProviderId;
+}({});
+const endpointToProvider = {
+	["openAI"]: "openai",
+	["azureOpenAI"]: "azure",
+	["anthropic"]: "anthropic",
+	["google"]: "google",
+	["bedrock"]: "bedrock"
+};
+const knownEndpointToProvider = {
+	["anyscale"]: "anyscale",
+	["apipie"]: "apipie",
+	["cohere"]: "cohere",
+	["fireworks"]: "fireworks",
+	["deepseek"]: "deepseek",
+	["moonshot"]: "moonshot",
+	["groq"]: "groq",
+	["helicone"]: "helicone",
+	["huggingface"]: "huggingface",
+	["mistral"]: "mistral",
+	["mlx"]: "mlx",
+	["ollama"]: "ollama",
+	["openrouter"]: "openrouter",
+	["perplexity"]: "perplexity",
+	["shuttleai"]: "shuttleai",
+	["together.ai"]: "together",
+	["unify"]: "unify",
+	["vercel"]: "vercel",
+	["xai"]: "xai"
+};
+const providerAliases = {
+	chatgpt: "openai",
+	gpt: "openai",
+	azureopenai: "azure",
+	claude: "anthropic",
+	gemini: "google",
+	gemma: "google",
+	vertex: "google",
+	vertexai: "google",
+	palm: "google",
+	awsbedrock: "bedrock",
+	grok: "xai",
+	kimi: "moonshot",
+	moonshotai: "moonshot",
+	mistralai: "mistral",
+	togetherai: "together"
+};
+const modelCatalogAliases = { ["vertexai"]: "google" };
+const normalize = (input) => input.toLowerCase().replace(/[\s._-]/g, "");
+const providerByNormalizedId = Object.values(ProviderId).reduce((acc, id) => {
+	acc[normalize(id)] = id;
+	return acc;
+}, {});
+/** Resolves free-form provider text to a canonical id, ignoring case and separators. */
+function resolveProviderId(input) {
+	if (!input) return null;
+	const key = normalize(input);
+	return providerByNormalizedId[key] ?? providerAliases[key] ?? null;
+}
+/** Resolves a runtime provider to its model catalog, using a native alias only when needed. */
+function resolveModelCatalogKey(provider, catalogs) {
+	const key = provider ?? "";
+	return catalogs?.[key] != null ? key : modelCatalogAliases[key] ?? key;
+}
+//#endregion
 //#region src/actions.ts
 function sha1(input) {
 	return crypto.createHash("sha1").update(input).digest("hex");
@@ -4940,6 +5914,27 @@ function extractDomainFromUrl(url) {
 		throw new Error(`Invalid URL format: ${url}`);
 	}
 }
+function getExplicitPort(value) {
+	const normalizedValue = value.trim();
+	const protocolSeparatorIndex = normalizedValue.indexOf("://");
+	const hasProtocol = protocolSeparatorIndex !== -1;
+	const authorityAndPath = hasProtocol ? normalizedValue.slice(protocolSeparatorIndex + 3) : normalizedValue;
+	let port;
+	try {
+		const parsedUrl = new URL(hasProtocol ? normalizedValue : `https://${normalizedValue}`);
+		port = parsedUrl.port;
+		if (!port && (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:")) port = new URL(`${parsedUrl.protocol === "http:" ? "https:" : "http:"}//${authorityAndPath}`).port;
+	} catch {
+		return null;
+	}
+	if (!port) return null;
+	const parsedPort = Number(port);
+	if (!Number.isInteger(parsedPort) || parsedPort < 1 || parsedPort > 65535) throw new Error(`Invalid port in domain: ${value}`);
+	return String(parsedPort);
+}
+function getDefaultActionPort(protocol) {
+	return protocol === "https:" ? "443" : "80";
+}
 /**
 * Validates client domain matches OpenAPI spec server URL domain (SSRF prevention).
 * @param clientProvidedDomain - Domain from client (with/without protocol)
@@ -4960,6 +5955,7 @@ function validateActionDomain(clientProvidedDomain, specServerUrl) {
 		/** Extract hostname from client domain if it's a full URL */
 		let clientHostname = clientProvidedDomain;
 		let clientHasProtocol = false;
+		const clientExplicitPort = getExplicitPort(clientProvidedDomain);
 		if (clientProvidedDomain.includes("://")) {
 			if (!clientProvidedDomain.startsWith("http://") && !clientProvidedDomain.startsWith("https://")) return {
 				isValid: false,
@@ -4971,7 +5967,7 @@ function validateActionDomain(clientProvidedDomain, specServerUrl) {
 			} catch {
 				clientHasProtocol = false;
 			}
-		}
+		} else if (clientExplicitPort !== null) clientHostname = new URL(`https://${clientProvidedDomain}`).hostname;
 		/** Normalize IPv6 addresses by removing brackets for comparison */
 		const normalizedClientHostname = clientHostname.replace(/^\[(.+)\]$/, "$1");
 		const normalizedSpecHostname = specHostname.replace(/^\[(.+)\]$/, "$1");
@@ -4984,14 +5980,23 @@ function validateActionDomain(clientProvidedDomain, specServerUrl) {
 			const hostname = isIP(normalizedClientHostname) === 6 && !clientHostname.startsWith("[") ? `[${normalizedClientHostname}]` : clientHostname;
 			normalizedClientDomain = `${specUrl.protocol}//${hostname}`;
 		} else normalizedClientDomain = `https://${clientHostname}`;
-		if (normalizedSpecDomain === normalizedClientDomain || !clientHasProtocol && isIPAddress && normalizedClientHostname === normalizedSpecHostname) return {
-			isValid: true,
+		if (!(normalizedSpecDomain === normalizedClientDomain || !clientHasProtocol && isIPAddress && normalizedClientHostname === normalizedSpecHostname)) return {
+			isValid: false,
+			message: `Domain mismatch: Client provided '${clientProvidedDomain}', but spec uses '${specHostname}'`,
 			normalizedSpecDomain,
 			normalizedClientDomain
 		};
+		if (clientExplicitPort !== null) {
+			const specEffectivePort = specUrl.port || getDefaultActionPort(specUrl.protocol);
+			if (clientExplicitPort !== specEffectivePort) return {
+				isValid: false,
+				message: `Port mismatch: Client provided '${clientProvidedDomain}', but spec uses effective port '${specEffectivePort}'`,
+				normalizedSpecDomain,
+				normalizedClientDomain
+			};
+		}
 		return {
-			isValid: false,
-			message: `Domain mismatch: Client provided '${clientProvidedDomain}', but spec uses '${specHostname}'`,
+			isValid: true,
 			normalizedSpecDomain,
 			normalizedClientDomain
 		};
@@ -5066,11 +6071,13 @@ function getUserTimezone() {
 	}
 }
 function createPayload(submission) {
-	const { isEdited, addedConvo, userMessage, isContinued, isTemporary, isRegenerate, conversation, editedContent, ephemeralAgent, endpointOption, manualSkills } = submission;
+	const { isEdited, addedConvo, userMessage, isContinued, isTemporary, isRegenerate, conversation, editedContent, ephemeralAgent, endpointOption, manualSkills, clientRequestId, recoverySteerId, expectedPredecessorCreatedAt } = submission;
 	const { conversationId } = tConvoUpdateSchema.parse(conversation);
 	const { endpoint: _e, endpointType } = endpointOption;
 	const endpoint = _e;
-	let server = `${EndpointURLs["agents"]}/${endpoint}`;
+	/** Custom endpoint names are user-defined and may contain `/`, which would
+	* otherwise split into extra path segments and miss the `/:endpoint` route. */
+	let server = `${EndpointURLs["agents"]}/${encodeURIComponent(endpoint)}`;
 	if (isAssistantsEndpoint(endpoint)) server = EndpointURLs[endpointType ?? endpoint] + (isEdited ? "/modify" : "");
 	const payload = {
 		...userMessage,
@@ -5084,7 +6091,10 @@ function createPayload(submission) {
 		isContinued: !!(isEdited && isContinued),
 		ephemeralAgent: isAssistantsEndpoint(endpoint) ? void 0 : ephemeralAgent,
 		manualSkills: isAssistantsEndpoint(endpoint) ? void 0 : manualSkills,
-		timezone: getUserTimezone()
+		timezone: getUserTimezone(),
+		clientRequestId,
+		recoverySteerId,
+		expectedPredecessorCreatedAt
 	};
 	return {
 		server,
@@ -5143,28 +6153,6 @@ const baseDefinitions = {
 		optionType: "conversation",
 		minTags: 0,
 		maxTags: 4
-	},
-	imageDetail: {
-		key: "imageDetail",
-		label: "com_endpoint_plug_image_detail",
-		labelCode: true,
-		description: "com_endpoint_openai_detail",
-		descriptionCode: true,
-		type: "enum",
-		default: "auto",
-		component: "slider",
-		options: [
-			"low",
-			"auto",
-			"high"
-		],
-		enumMappings: {
-			["low"]: "com_ui_low",
-			["auto"]: "com_ui_auto",
-			["high"]: "com_ui_high"
-		},
-		optionType: "conversation",
-		columnSpan: 2
 	}
 };
 const createDefinition = (base, overrides) => {
@@ -5191,7 +6179,7 @@ const librechat = {
 		labelCode: true,
 		type: "number",
 		component: "input",
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		description: "com_endpoint_context_info",
 		descriptionCode: true,
@@ -5222,13 +6210,37 @@ const librechat = {
 		placeholderCode: true,
 		optionType: "model"
 	},
+	/** Controls how LibreChat encodes image content blocks, not a provider request
+	* parameter — so it belongs to this group and is stripped from model options. */
+	imageDetail: {
+		key: "imageDetail",
+		label: "com_endpoint_plug_image_detail",
+		labelCode: true,
+		description: "com_endpoint_openai_detail",
+		descriptionCode: true,
+		type: "enum",
+		default: "auto",
+		component: "slider",
+		options: [
+			"low",
+			"auto",
+			"high"
+		],
+		enumMappings: {
+			["low"]: "com_ui_low",
+			["auto"]: "com_ui_auto",
+			["high"]: "com_ui_high"
+		},
+		optionType: "conversation",
+		columnSpan: 2
+	},
 	fileTokenLimit: {
 		key: "fileTokenLimit",
 		label: "com_ui_file_token_limit",
 		labelCode: true,
 		description: "com_ui_file_token_limit_desc",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		type: "number",
 		component: "input",
@@ -5300,7 +6312,7 @@ const openAIParams = {
 		component: "input",
 		description: "com_endpoint_openai_max_tokens",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		optionType: "model",
 		columnSpan: 2
@@ -5321,7 +6333,8 @@ const openAIParams = {
 			"low",
 			"medium",
 			"high",
-			"xhigh"
+			"xhigh",
+			"max"
 		],
 		enumMappings: {
 			[""]: "com_ui_auto",
@@ -5330,7 +6343,8 @@ const openAIParams = {
 			["low"]: "com_ui_low",
 			["medium"]: "com_ui_medium",
 			["high"]: "com_ui_high",
-			["xhigh"]: "com_ui_xhigh"
+			["xhigh"]: "com_ui_xhigh",
+			["max"]: "com_ui_max"
 		},
 		optionType: "model",
 		columnSpan: 4
@@ -5385,6 +6399,52 @@ const openAIParams = {
 		optionType: "model",
 		columnSpan: 4
 	},
+	reasoning_mode: {
+		key: "reasoning_mode",
+		label: "com_endpoint_reasoning_mode",
+		labelCode: true,
+		description: "com_endpoint_openai_reasoning_mode",
+		descriptionCode: true,
+		type: "enum",
+		default: "",
+		component: "slider",
+		options: [
+			"",
+			"standard",
+			"pro"
+		],
+		enumMappings: {
+			[""]: "com_ui_unset",
+			["standard"]: "com_ui_standard",
+			["pro"]: "com_ui_pro"
+		},
+		optionType: "model",
+		columnSpan: 4
+	},
+	reasoning_context: {
+		key: "reasoning_context",
+		label: "com_endpoint_reasoning_context",
+		labelCode: true,
+		description: "com_endpoint_openai_reasoning_context",
+		descriptionCode: true,
+		type: "enum",
+		default: "",
+		component: "slider",
+		options: [
+			"",
+			"auto",
+			"current_turn",
+			"all_turns"
+		],
+		enumMappings: {
+			[""]: "com_ui_unset",
+			["auto"]: "com_ui_auto",
+			["current_turn"]: "com_ui_current_turn",
+			["all_turns"]: "com_ui_all_turns"
+		},
+		optionType: "model",
+		columnSpan: 4
+	},
 	verbosity: {
 		key: "verbosity",
 		label: "com_endpoint_verbosity",
@@ -5432,7 +6492,7 @@ const anthropic = {
 		component: "input",
 		description: "com_endpoint_anthropic_maxoutputtokens",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		range: {
 			min: anthropicSettings.maxOutputTokens.min,
@@ -5620,7 +6680,7 @@ const bedrock = {
 		component: "input",
 		description: "com_endpoint_anthropic_maxoutputtokens",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		optionType: "model",
 		columnSpan: 2
@@ -5752,6 +6812,14 @@ const meta = {
 	})
 };
 const google = {
+	/** Bounds the hand-rolled editor enforced through InputNumber, and they stay
+	*  scoped to this endpoint: the shared definition is rendered by every other
+	*  endpoint, whose own context windows may fall outside them. */
+	maxContextTokens: createDefinition(librechat.maxContextTokens, { range: {
+		min: googleSettings.maxContextTokens.min,
+		max: googleSettings.maxContextTokens.max,
+		step: googleSettings.maxContextTokens.step
+	} }),
 	temperature: createDefinition(baseDefinitions.temperature, {
 		default: googleSettings.temperature.default,
 		range: {
@@ -5793,7 +6861,7 @@ const google = {
 		component: "input",
 		description: "com_endpoint_google_maxoutputtokens",
 		descriptionCode: true,
-		placeholder: "com_nav_theme_system",
+		placeholder: "com_endpoint_default",
 		placeholderCode: true,
 		default: googleSettings.maxOutputTokens.default,
 		range: {
@@ -5891,7 +6959,7 @@ const google = {
 const googleConfig = [
 	librechat.modelLabel,
 	librechat.promptPrefix,
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -5910,7 +6978,7 @@ const googleCol1 = [
 	librechat.promptPrefix
 ];
 const googleCol2 = [
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -5934,11 +7002,13 @@ const openAI = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.web_search,
 	openAIParams.reasoning_effort,
 	openAIParams.useResponsesApi,
 	openAIParams.reasoning_summary,
+	openAIParams.reasoning_mode,
+	openAIParams.reasoning_context,
 	openAIParams.verbosity,
 	openAIParams.disableStreaming,
 	librechat.fileTokenLimit
@@ -5962,9 +7032,11 @@ const openAICol2 = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.reasoning_effort,
 	openAIParams.reasoning_summary,
+	openAIParams.reasoning_mode,
+	openAIParams.reasoning_context,
 	openAIParams.verbosity,
 	openAIParams.useResponsesApi,
 	openAIParams.web_search,
@@ -6267,13 +7339,71 @@ const agentParamSettings = Object.entries(presetSettings).reduce((acc, [key, val
 * Resolves model-aware defaults for a settings configuration before rendering.
 * Google's `maxOutputTokens` default depends on the selected Gemini model so that
 * current models (2.5 and 3+) surface their 64K output limit instead of the legacy 8K value.
+* Anthropic prompt-cache controls are only surfaced for models that support them.
 */
 function applyModelAwareDefaults(settings, endpoint, model) {
-	if (endpoint !== "google" || !model) return settings;
-	return settings.map((setting) => setting.key === "maxOutputTokens" ? {
-		...setting,
-		default: googleSettings.maxOutputTokens.reset(model)
-	} : setting);
+	if (!model) return settings;
+	const modelAwareSettings = endpoint === "google" ? settings.map((setting) => {
+		if (setting.key === "maxOutputTokens") return {
+			...setting,
+			default: googleSettings.maxOutputTokens.reset(model)
+		};
+		/** The shared thinking budget range is model-agnostic, so it caps Pro below
+		*  its real ceiling and accepts Flash values the provider rejects. The
+		*  maximum and the positive floor move together. `range.min` stays -1 so
+		*  the "decide automatically" sentinel remains typeable. */
+		if (setting.key === "thinkingBudget" && setting.range != null) {
+			const bounds = getGoogleThinkingBudgetBounds(model);
+			if (bounds != null) return {
+				...setting,
+				range: {
+					...setting.range,
+					max: bounds.max,
+					positiveMin: bounds.min,
+					modelSpecific: true
+				}
+			};
+		}
+		return setting;
+	}) : settings;
+	if (endpoint !== "anthropic" || supportsPromptCache(model)) return modelAwareSettings;
+	return modelAwareSettings.filter((setting) => setting.key !== "promptCache" && setting.key !== "promptCacheTtl");
+}
+//#endregion
+//#region src/agentToolOptions.ts
+const actionDomainSeparatorRegex = /* @__PURE__ */ new RegExp("---", "g");
+/**
+* Collapses the encoded-domain suffix of an action tool name to the shape used
+* by runtime tool definitions. The operation id is deliberately preserved.
+*/
+function normalizeActionToolName(toolName) {
+	if (!isActionTool(toolName)) return toolName;
+	const prefixEnd = toolName.lastIndexOf(actionDelimiter) + actionDelimiter.length;
+	const encodedDomain = toolName.slice(prefixEnd);
+	return toolName.slice(0, prefixEnd) + encodedDomain.replace(actionDomainSeparatorRegex, "_");
+}
+/**
+* Removes Code Interpreter as an allowed caller without mutating the input.
+* Tool entries and unrelated options are preserved; an empty entry is removed.
+*/
+function removeCodeExecutionCaller(toolOptions) {
+	if (toolOptions == null) return toolOptions;
+	const normalized = {};
+	for (const [toolName, options] of Object.entries(toolOptions)) {
+		const callers = options.allowed_callers;
+		if (callers?.includes("code_execution") !== true) {
+			normalized[toolName] = options;
+			continue;
+		}
+		const allowedCallers = callers.filter((caller) => caller !== "code_execution");
+		const { allowed_callers: _removed, ...remainingOptions } = options;
+		const nextOptions = allowedCallers.length > 0 ? {
+			...remainingOptions,
+			allowed_callers: allowedCallers
+		} : remainingOptions;
+		if (Object.keys(nextOptions).length > 0) normalized[toolName] = nextOptions;
+	}
+	return normalized;
 }
 //#endregion
 //#region src/codeEnvRef.ts
@@ -6300,7 +7430,32 @@ const CODE_ENV_KINDS = [
 	"agent",
 	"user"
 ];
+function getCodeEnvRefForProfile(refs, routeKey) {
+	const profileRef = refs?.codeEnvRefs?.[routeKey];
+	if (profileRef) return profileRef;
+	const legacyRef = refs?.codeEnvRef;
+	if (legacyRef && (legacyRef.executionRouteKey ?? legacyRef.executionProfile ?? "default") === routeKey) return legacyRef;
+}
+/** Adds one profile pointer without discarding the other profile's storage object. */
+function mergeCodeEnvRef(refs, ref) {
+	const codeEnvRefs = { ...refs?.codeEnvRefs };
+	const legacyRef = refs?.codeEnvRef;
+	if (legacyRef) codeEnvRefs[legacyRef.executionRouteKey ?? legacyRef.executionProfile ?? "default"] ??= legacyRef;
+	const routeKey = ref.executionRouteKey ?? ref.executionProfile ?? "default";
+	codeEnvRefs[routeKey] = ref;
+	return {
+		codeEnvRef: codeEnvRefs.default ?? codeEnvRefs.stateful ?? ref,
+		codeEnvRefs
+	};
+}
+/** Enumerates every deployment-local pointer, including legacy single-pointer records. */
+function getCodeEnvRefs(refs) {
+	const merged = { ...refs?.codeEnvRefs };
+	const legacyRef = refs?.codeEnvRef;
+	if (legacyRef) merged[legacyRef.executionRouteKey ?? legacyRef.executionProfile ?? "default"] ??= legacyRef;
+	return Object.entries(merged).flatMap(([routeKey, ref]) => ref ? [[routeKey, ref]] : []);
+}
 //#endregion
-export { AccessRoleIds, ActionRequest, AgentCapabilities, AnnotationTypes, AnthropicEffort, ArtifactModes, AssistantStreamEvents, AuthKeys, AuthType, AuthTypeEnum, AuthorizationTypeEnum, BASE_ONLY_CONFIG_SECTIONS, BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA, BEDROCK_OUTPUT_128K_BETA, BedrockProviders, BedrockReasoningConfig, CODE_ENV_KINDS, CacheKeys, Capabilities, CohereConstants, ComponentTypes, Constants, ContentTypes, DATE_RANGE, DEFAULT_MEMORY_MAX_INPUT_TOKENS, DynamicQueryKeys, EImageOutputType, EModelEndpoint, EToolResources, EndpointURLs, ErrorTypes, FEEDBACK_RATINGS, FEEDBACK_REASON_KEYS, FEEDBACK_TAGS, FetchTokenConfig, FileContext, FilePurpose, FileSources, ForkOptions, FunctionSignature, INTERFACE_PERMISSION_FIELDS, ImageDetail, ImageDetailCost, ImageVisionTool, InfiniteCollections, InvocationMode, KnownEndpoints, LocalStorageKeys, MAX_SUBAGENTS, MAX_SUBAGENT_DEPTH, MAX_SUBAGENT_GRAPH_NODES, MAX_SUBAGENT_RUN_CONFIGS, MCPOptionsSchema, MCPServerUserInputSchema, MCPServersSchema, MCP_USER_INPUT_FIELDS, MYTHOS_CLASS_FAMILIES, MessageContentTypes, MutationKeys, OCRStrategy, OptionTypes, PERMISSION_SUB_KEYS, PERMISSION_TYPE_INTERFACE_FIELDS, PermissionBits, PermissionTypes, Permissions, PrincipalModel, PrincipalType, Providers, QueryKeys, REFILL_INTERVAL_UNITS, RateLimitPrefix, ReasoningEffort, ReasoningParameterFormat, ReasoningResponseKey, ReasoningSummary, RerankerTypes, ResourceType, RetentionMode, RunStatus, SEPARATORS, SKILL_BODY_MAX_LENGTH, SKILL_DESCRIPTION_MAX_LENGTH, SKILL_DESCRIPTION_SHORT_THRESHOLD, SKILL_DISPLAY_TITLE_MAX_LENGTH, SKILL_NAME_MAX_LENGTH, SKILL_NAME_PATTERN, SKILL_SYNC_DEFAULT_DISCOVERY_DEPTH, SKILL_SYNC_MAX_DISCOVERY_DEPTH, SKILL_SYNC_MAX_INTERVAL_MINUTES, SKILL_SYNC_MIN_INTERVAL_MINUTES, SSEOptionsSchema, STTProviders, SafeSearchTypes, ScraperProviders, SearchCategories, SearchProviders, SettingTypes, SettingsTabValues, SettingsViews, StdioOptionsSchema, StepEvents, StepStatus, StepTypes, StreamableHTTPOptionsSchema, SystemCategories, SystemRoles, TTSProviders, ThinkingDisplay, ThinkingLevel, Time, TokenExchangeMethodEnum, ToolCallTypes, Tools, UsageEvents, Verbosity, ViolationTypes, VisionModes, WebSocketOptionsSchema, accessRoleSchema, accessRoleToPermBits, accordian, actionDelimiter, actionDomainSeparator, agentParamSettings, agentPermissionsSchema, agentsBaseSchema, agentsEndpointSchema, agentsSchema, agentsSettings, alert, alertDialog, allowedAddressesSchema, alternateName, anthropicBaseSchema, anthropicEndpointSchema, anthropicSchema, anthropicSettings, apiBaseUrl, appendAgentIdSuffix, applicationMimeTypes, applyModelAwareDefaults, assistantEndpointSchema, assistantSchema, audioMimeTypes, authTypeSchema, avatar, azureBaseSchema, azureEndpointSchema, azureGroupConfigsSchema, azureGroupSchema, badge, balanceSchema, baseEndpointSchema, bedrockDocumentExtensions, bedrockDocumentFormats, bedrockEndpointSchema, bedrockGuardrailConfigSchema, bedrockInputParser, bedrockInputSchema, bedrockModels, bedrockOutputParser, bookmarkPermissionsSchema, breadcrumb, buildLoginRedirectUrl, buildTree, button, cacheSubsetProviders, calendar, card, carousel, checkOpenAIStorage, checkbox, cloudfrontConfigSchema, codeInterpreterMimeTypes, codeInterpreterMimeTypesList, codeTypeMapping, coerceNumber, collapsible, compactAgentsBaseSchema, compactAgentsSchema, compactAssistantSchema, compactGoogleSchema, configSchema, contextPruningSchema, convertStringsToRegex, createPayload, createURL, data_service_exports as dataService, defaultAgentCapabilities, defaultAgentFormValues, defaultAssistantFormValues, defaultAssistantsVersion, defaultEndpoints, defaultModels, defaultOCRMimeTypes, defaultOrderQuery, defaultRetrievalModels, defaultSTTMimeTypes, defaultSocialLogins, defaultTextMimeTypes, dialog, documentParserMimeTypes, documentSupportedProviders, drawer, dropdownMenu, eAnthropicEffortSchema, eImageDetailSchema, eModelEndpointSchema, eReasoningEffortSchema, eReasoningParameterFormatSchema, eReasoningResponseKeySchema, eReasoningSummarySchema, eThinkingDisplaySchema, eThinkingLevelSchema, eVerbositySchema, effectivePermissionsResponseSchema, encodeEphemeralAgentId, endpointFileConfigSchema, endpointSchema, endpointSettings, envVarRegex, errorsToString, essentialShadcnComponents, excelFileTypes, excelMimeTypes, excludedKeys, extendedModelEndpointSchema, extractDomainFromUrl, extractEnvVariable, extractVariableName, feedbackRatingSchema, feedbackSchema, feedbackTagKeySchema, fileCitationsPermissionsSchema, fileConfig, fileConfigSchema, fileSearchPermissionsSchema, fileSourceSchema, fileStorageSchema, fileStrategiesSchema, findLastSeparatorIndex, fullMimeTypesList, generateDynamicSchema, generateGoogleSchema, generateOpenAISchema, getConfigDefaults, getDefaultParamsEndpoint, getEnabledEndpoints, getEndpointField, getEndpointFileConfig, getFirstDefinedValue, getModelKey, getNonEmptyValue, getRefillEligibilityDate, getResourcePermissionsResponseSchema, getResponseSender, getSchemaDefaults, getSettingsKeys, getTagByKey, getTagsForRating, getTokenHeader, googleBaseSchema, googleGenConfigSchema, googleSchema, googleSettings, hasPermissions, hostImageIdSuffix, hostImageNamePrefix, hoverCard, imageDetailNumeric, imageDetailValue, imageExtRegex, imageGenTools, imageMimeTypes, imageTypeMapping, inferMimeType, initialModelsConfig, input, inputTokensIncludesCache, interfaceSchema, isActionTool, isAgentsEndpoint, isAssistantsEndpoint, isBedrockDocumentType, isDocumentSupportedProvider, isEphemeralAgentId, isImageVisionTool, isMythosClassModel, isOpenAILikeProvider, isParamEndpoint, isPermissiveMimeConfig, isRemoteOidcUrlAllowed, isSensitiveEnvVar, isSystemRoleName, isUUID, label, librechat, loginPage, mapGroupToAzureConfig, mapModelToAzureConfig, marketplacePermissionsSchema, mbToBytes, mcpServersPermissionsSchema, megabyte, memoryPermissionsSchema, memorySchema, menuBar, mergeFileConfig, messageFilterPiiSchema, messageFilterSchema, mimeTypeAliases, modelConfigSchema, modelSpecSubagentsSchema, modularEndpoints, multiConvoPermissionsSchema, navigationMenu, normalizeEndpointName, ocrSchema, omitsSamplingParameters, omitsThinkingByDefault, openAIBaseSchema, openAISchema, openAISettings, openRouterSchema, openapiToFunction, orderEndpointsConfig, pagination, paramDefinitionSchema, paramEndpoints, paramSettings, parseCompactConvo, parseConvo, parseEphemeralAgentId, parseTextParts, peoplePickerPermissionsSchema, permBitsToAccessLevel, permissionEntrySchema, permissionsSchema, popover, presetSettings, principalSchema, progress, promptPermissionsSchema, promptTokensFromUsage, providerEndpointMap, radioGroup, rateLimitSchema, reconcileContextUsage, registerPage, remoteAgentsPermissionsSchema, removeNullishValues, replaceSpecialVars, request_default as request, resolveEndpointType, resolveRef, resolveThinkingDisplay, resourcePermissionsResponseSchema, retrievalMimeTypes, retrievalMimeTypesList, roleDefaults, roleSchema, runCodePermissionsSchema, select, separator, setAcceptLanguageHeader, setTokenHeader, sha1, shadcnComponents, sharedFileDownload, sharedLinksPermissionsSchema, skeleton, skillPermissionsSchema, skillSyncConfigSchema, skillSyncGitHubSourceSchema, slider, specialVariables, specsConfigSchema, stripAgentIdSuffix, summarizationConfigSchema, summarizationTriggerSchema, supportedMimeTypes, supportsAdaptiveThinking, supportsBalanceCheck, supportsContext1m, supportsFiles, switchComponent, tBannerSchema, tConversationSchema, tConversationTagSchema, tConvoUpdateSchema, tExampleSchema, tMessageSchema, tModelSpecPresetSchema, tModelSpecSchema, tPluginAuthConfigSchema, tPluginSchema, tPresetSchema, tQueryParamsSchema, tSharedLinkSchema, table, tabs, temporaryChatPermissionsSchema, textMimeTypes, textarea, toMinimalFeedback, toast, toaster, toggle, toggleGroup, tooltip, transactionsSchema, turnstileOptionsSchema, turnstileSchema, updateResourcePermissionsRequestSchema, updateResourcePermissionsResponseSchema, useToast, utils, validateActionDomain, validateAndParseOpenAPISpec, validateAzureGroups, validateSettingDefinitions, validateVisionModel, vertexAISchema, vertexModelConfigSchema, videoMimeTypes, visionModels, webSearchPermissionsSchema, webSearchSchema };
+export { ACTION_METADATA_FILTER_FIELDS, AGENT_INSTRUCTION_FILTER_FIELDS, AUTH_USER_DOC_BY_ID_PREFIX, AccessRoleIds, ActionRequest, ActivityLabelEvents, AgentCapabilities, AnnotationTypes, AnthropicEffort, ApprovalEvents, ArtifactModes, AssistantStreamEvents, AuthKeys, AuthType, AuthTypeEnum, AuthorizationTypeEnum, BASE_ONLY_CONFIG_SECTIONS, BASE_PRINCIPAL_CONFIG_SECTIONS, BEDROCK_FINE_GRAINED_TOOL_STREAMING_BETA, BEDROCK_OUTPUT_128K_BETA, BedrockProviders, BedrockReasoningConfig, CODE_ENV_KINDS, CONVERSATION_STARTER_FILTER_FIELDS, CONVERSATION_TITLE_FILTER_FIELDS, CacheKeys, Capabilities, CohereConstants, ComponentTypes, Constants, ContentTypes, DATE_RANGE, DEFAULT_MEMORY_MAX_INPUT_TOKENS, DynamicQueryKeys, EImageOutputType, EModelEndpoint, EToolResources, EndpointURLs, ErrorTypes, FEEDBACK_FILTER_FIELDS, FEEDBACK_RATINGS, FEEDBACK_REASON_KEYS, FEEDBACK_TAGS, FILE_FILTER_FIELDS, FILTER_PII_STARTER_PATTERNS, FetchTokenConfig, FileContext, FilePurpose, FileSources, ForkOptions, FunctionSignature, HITL_MESSAGE_FILTER_FIELDS, INSIGHTS_MAX_RANGE_DAYS, INSIGHTS_SEARCH_MAX_LENGTH, INSIGHTS_SEARCH_MIN_LENGTH, INTERFACE_PERMISSION_FIELDS, ImageDetail, ImageDetailCost, ImageVisionTool, InfiniteCollections, InvocationMode, KnownEndpoints, LocalStorageKeys, MAX_CHAT_PROJECT_DESCRIPTION_LENGTH, MAX_CHAT_PROJECT_NAME_LENGTH, MAX_GRAPH_SUBAGENT_MEMBERS, MAX_PII_CUSTOM_PATTERNS_TOTAL, MAX_PII_CUSTOM_REGEX_CHARACTERS, MAX_PII_CUSTOM_REGEX_INSTRUCTIONS, MAX_PII_PATTERNS_PER_SOURCE, MAX_PII_PATTERN_ID_LENGTH, MAX_PII_PATTERN_LABEL_LENGTH, MAX_PII_PATTERN_LENGTH, MAX_SUBAGENTS, MAX_SUBAGENTS_CEILING, MAX_SUBAGENT_DEPTH, MAX_SUBAGENT_GRAPH_NODES, MAX_SUBAGENT_RUN_CONFIGS, MCPOptionsSchema, MCPServerUserInputSchema, MCPServersSchema, MCP_SERVER_TITLE_ERROR, MCP_SERVER_TITLE_PATTERN, MCP_USER_INPUT_FIELDS, MEMORY_FILTER_FIELDS, MESSAGE_FILTER_FIELDS, MIN_REPORTABLE_RUN_STEP_DURATION_MS, MODEL_PARAMETER_FILTER_FIELDS, MYTHOS_CLASS_FAMILIES, MemoryScope, MessageContentTypes, MutationKeys, OCRStrategy, OptionTypes, PERMISSION_SUB_KEYS, PERMISSION_TYPE_INTERFACE_FIELDS, PROMPT_FILTER_FIELDS, PermissionBits, PermissionTypes, Permissions, PrincipalModel, PrincipalType, ProviderId, Providers, QueryKeys, REFILL_INTERVAL_UNITS, RUNTIME_CONFIG_INTERFACE_FIELDS, RateLimitPrefix, ReasoningContext, ReasoningEffort, ReasoningLabelEvents, ReasoningMode, ReasoningParameterFormat, ReasoningResponseKey, ReasoningSummary, RerankerTypes, ResourceType, RetentionMode, RunStatus, SCHEDULE_CRON_MAX_LENGTH, SEPARATORS, SKILL_BODY_MAX_LENGTH, SKILL_DESCRIPTION_MAX_LENGTH, SKILL_DESCRIPTION_SHORT_THRESHOLD, SKILL_DISPLAY_TITLE_MAX_LENGTH, SKILL_FILTER_FIELDS, SKILL_NAME_MAX_LENGTH, SKILL_NAME_PATTERN, SKILL_SYNC_DEFAULT_DISCOVERY_DEPTH, SKILL_SYNC_MAX_DISCOVERY_DEPTH, SKILL_SYNC_MAX_INTERVAL_MINUTES, SKILL_SYNC_MIN_INTERVAL_MINUTES, SSEOptionsSchema, STATEFUL_CODE_ENVIRONMENTS, STORED_MESSAGE_FILTER_FIELDS, STTProviders, SafeSearchTypes, ScraperProviders, SearchCategories, SearchProviders, SettingTypes, SettingsTabValues, SettingsViews, SkillsScope, StdioOptionsSchema, SteerEvents, StepEvents, StepStatus, StepTypes, StreamableHTTPOptionsSchema, SystemCategories, SystemRoles, TOOL_ARGUMENT_FILTER_FIELDS, TTSProviders, ThinkingDisplay, ThinkingLevel, Time, TokenExchangeMethodEnum, ToolCallTypes, Tools, UsageEvents, Verbosity, ViolationTypes, VisionModes, WebSocketOptionsSchema, accessRoleSchema, accessRoleToPermBits, accordian, actionDelimiter, actionDomainSeparator, actionMetadataFilterFieldSchema, agentInstructionFilterFieldSchema, agentParamSettings, agentPermissionsSchema, agentQueuedTurnCapabilitySchema, agentQueuedTurnDurability, agentQueuedTurnFileRefSchema, agentQueuedTurnReceiptSchema, agentQueuedTurnStatuses, agentsBaseSchema, agentsEndpointSchema, agentsSchema, agentsSettings, alert, alertDialog, allowedAddressesSchema, alternateName, anthropicBaseSchema, anthropicEndpointSchema, anthropicSchema, anthropicSettings, apiBaseUrl, appendAgentIdSuffix, applicationMimeTypes, applyModelAwareDefaults, assistantEndpointSchema, assistantSchema, audioMimeTypes, authTypeSchema, avatar, azureBaseSchema, azureEndpointSchema, azureGroupConfigsSchema, azureGroupSchema, badge, balanceSchema, baseEndpointSchema, bedrockDocumentExtensions, bedrockDocumentFormats, bedrockDocumentMimeTypes, bedrockEndpointSchema, bedrockGuardrailConfigSchema, bedrockInputParser, bedrockInputSchema, bedrockModels, bedrockOutputParser, bookmarkPermissionsSchema, breadcrumb, buildLoginRedirectUrl, buildServerNameAliases, buildTree, button, cacheSubsetProviders, cadenceIntervalMinutes, cadenceToCron, calendar, cancelAgentQueuedTurnResponseSchema, cancelAgentQueuedTurnSchema, capsEffortWhenThinkingDisabled, card, carousel, checkOpenAIStorage, checkbox, checkpointerSchema, checkpointerTypeSchema, clampEffortForDisabledThinking, clampOutputConfigEffort, clampSettingRange, cloudfrontConfigSchema, codeEnvironmentPermissionDecisionSchema, codeEnvironmentUserConfigSchema, codeEnvironmentUserSettingsSchema, codeInterpreterMimeTypes, codeInterpreterMimeTypesList, codeTypeMapping, coerceNumber, collapsible, compactAgentsBaseSchema, compactAgentsSchema, compactAssistantSchema, compactGoogleSchema, configSchema, contextPruningSchema, conversationStarterFilterFieldSchema, conversationTitleFilterFieldSchema, convertStringsToRegex, createPayload, createSchedulePayloadSchema, createURL, cronCadenceSchema, data_service_exports as dataService, defaultAgentCapabilities, defaultAgentFormValues, defaultAssistantFormValues, defaultAssistantsVersion, defaultEndpoints, defaultModels, defaultOCRMimeTypes, defaultOrderQuery, defaultRetrievalModels, defaultSTTMimeTypes, defaultSocialLogins, defaultTextMimeTypes, dialog, documentParserMimeTypes, documentSupportedProviders, drawer, dropdownMenu, eAnthropicEffortSchema, eImageDetailSchema, eModelEndpointSchema, eReasoningContextSchema, eReasoningEffortSchema, eReasoningModeSchema, eReasoningParameterFormatSchema, eReasoningResponseKeySchema, eReasoningSummarySchema, eThinkingDisplaySchema, eThinkingLevelSchema, eVerbositySchema, effectivePermissionsResponseSchema, encodeEphemeralAgentId, endpointFileConfigSchema, endpointSchema, endpointSettings, endpointToProvider, enqueueAgentQueuedTurnResponseSchema, enqueueAgentQueuedTurnSchema, envVarRegex, errorsToString, essentialShadcnComponents, excelFileTypes, excelMimeTypes, excludedKeys, extendedModelEndpointSchema, extractDomainFromUrl, extractEnvVariable, extractVariableName, feedbackFilterFieldSchema, feedbackRatingSchema, feedbackSchema, feedbackTagKeySchema, fileCitationsPermissionsSchema, fileConfig, fileConfigSchema, fileFilterFieldSchema, fileSearchPermissionsSchema, fileSourceSchema, fileStorageSchema, fileStrategiesSchema, filterPiiActionSchema, filterPiiCustomPatternSchema, filterPiiRegexSchema, filterPiiStarterPatternSchema, filtersConfigSchema, findLastSeparatorIndex, fullMimeTypesList, generateDynamicSchema, generateGoogleSchema, generateOpenAISchema, getCodeEnvRefForProfile, getCodeEnvRefs, getConfigDefaults, getConfiguredMimeAccept, getDefaultParamsEndpoint, getEnabledEndpoints, getEndpointField, getEndpointFileConfig, getEphemeralSender, getFirstDefinedValue, getGoogleThinkingBudgetBounds, getGoogleThinkingBudgetMax, getMaxSubagents, getModelKey, getNonEmptyValue, getPiiRegexProgramSize, getRefillEligibilityDate, getResourcePermissionsResponseSchema, getResponseSender, getRunStepDurationMs, getSchemaDefaults, getSettingsKeys, getTagByKey, getTagsForRating, getTokenHeader, googleBaseSchema, googleGenConfigSchema, googleSchema, googleSettings, hasActiveFiltersConfig, hasActivePiiFields, hasActivePiiPatterns, hasPermissions, hasProcessMCPServerConfig, hostImageIdSuffix, hostImageNamePrefix, hoverCard, imageDetailNumeric, imageDetailValue, imageExtRegex, imageGenTools, imageMimeTypes, imageTypeMapping, inferMimeType, initialModelsConfig, input, inputTokensIncludesCache, interfaceSchema, isActionTool, isAgentsEndpoint, isAnthropicDocumentType, isAnthropicTextDocumentType, isAssistantsEndpoint, isBedrockDocumentType, isCronCadence, isDocumentSupportedProvider, isEphemeralAgentId, isImageVisionTool, isMythosClassModel, isOpenAILikeProvider, isParamEndpoint, isPermissiveMimeConfig, isProcessMCPServerConfig, isProcessMCPServerField, isRemoteOidcUrlAllowed, isReportableRunStepDuration, isSecureCodeEnvironmentControlURL, isSensitiveEnvVar, isSystemRoleName, isThinkingDisabled, isUUID, isValidCronExpression, knownEndpointToProvider, label, langfuseConfigSchema, librechat, listAgentQueuedTurnsResponseSchema, listAgentQueuedTurnsSchema, loginPage, mapGroupToAzureConfig, mapModelToAzureConfig, marketplacePermissionsSchema, materializeModelSpecEndpoints, mbToBytes, mcpServersPermissionsSchema, megabyte, memoryFilterFieldSchema, memoryPermissionsSchema, memorySchema, menuBar, mergeCodeEnvRef, mergeFileConfig, messageFilterFieldSchema, messageFilterPiiSchema, messageFilterSchema, mimeTypeAliases, modelConfigSchema, modelParameterFilterFieldSchema, modelSpecSubagentsSchema, modularEndpoints, multiConvoPermissionsSchema, navigationMenu, nextRunInstants, normalizeActionToolName, normalizeEndpointName, normalizeMCPToolKey, normalizeSearxngEngines, normalizeServerName, ocrSchema, omitsSamplingParameters, omitsThinkingByDefault, openAIBaseSchema, openAISchema, openAISettings, openRouterSchema, openapiToFunction, orderEndpointsConfig, pagination, paramDefinitionSchema, paramEndpoints, paramSettings, parseCompactConvo, parseConvo, parseEphemeralAgentId, parseLangChainErrorCode, parseTextParts, peoplePickerPermissionsSchema, permBitsToAccessLevel, permissionEntrySchema, permissionsSchema, popover, presetSettings, principalSchema, progress, promptFilterFieldSchema, promptPermissionsSchema, promptTokensFromUsage, providerEndpointMap, radioGroup, rateLimitSchema, reconcileContextUsage, registerPage, remoteAgentsPermissionsSchema, removeCodeExecutionCaller, removeNullishValues, replaceSpecialVars, request_default as request, requiresExplicitThinkingDisabled, resolveAgentSkillsScope, resolveAllowedStatefulCodeEnvironments, resolveEndpointType, resolveModelCatalogKey, resolveModelSpecEndpoint, resolveProviderId, resolveRef, resolveStatefulCodeEnvironment, resolveThinkingDisplay, resourcePermissionsResponseSchema, retainRecentConfigSchema, retrievalMimeTypes, retrievalMimeTypesList, roleDefaults, roleSchema, runCodePermissionsSchema, scheduleCadenceSchema, scheduleFrequencies, scheduleStructuredFrequencies, scheduleTargets, schedulesPermissionsSchema, select, separator, setAcceptLanguageHeader, setFileConfigRegexCompiler, setMaxSubagents, setMessageFilterRegexValidator, setTokenHeader, sha1, shadcnComponents, sharedFileDownload, sharedLinksPermissionsSchema, skeleton, skillFilterFieldSchema, skillPermissionsSchema, skillSyncConfigSchema, skillSyncGitHubSourceSchema, slider, specialVariables, specsConfigSchema, splitMCPToolKey, splitToolCallName, stripAgentIdSuffix, stripLangChainTroubleshootingUrl, stripReasoningLabelMetadata, stripServerNamePrefix, stripServerNamePrefixes, structuredCadenceSchema, subagentThreadLineageSchema, summarizationConfigSchema, summarizationTriggerSchema, supportedMimeTypes, supportsAdaptiveThinking, supportsBalanceCheck, supportsContext1m, supportsFiles, supportsPromptCache, switchComponent, tBannerSchema, tConversationSchema, tConversationTagSchema, tConvoUpdateSchema, tExampleSchema, tMessageSchema, tModelSpecPresetSchema, tModelSpecSchema, tPluginAuthConfigSchema, tPluginSchema, tPresetSchema, tQueryParamsSchema, tSharedLinkSchema, table, tabs, temporaryChatPermissionsSchema, textMimeTypes, textarea, toMinimalFeedback, toast, toaster, toggle, toggleGroup, toolApprovalHookConfigSchema, toolApprovalModeSchema, toolApprovalPolicySchema, toolArgumentFilterFieldSchema, tooltip, transactionsSchema, turnstileOptionsSchema, turnstileSchema, unattributedAssistantContentSchema, updateResourcePermissionsRequestSchema, updateResourcePermissionsResponseSchema, updateSchedulePayloadSchema, useToast, userSubmittedMessageFieldPathSchema, utils, validateActionDomain, validateAndParseOpenAPISpec, validateAzureGroups, validateSettingDefinitions, validateVisionModel, vertexAISchema, vertexModelConfigSchema, videoMimeTypes, visionModels, webSearchPermissionsSchema, webSearchSchema };
 
 //# sourceMappingURL=index.mjs.map