librechat-data-provider 0.8.521 → 0.8.523

package/dist/index.mjs

@@ -1,8 +1,9 @@
-import { $ as permissionEntrySchema, $a as tMessageSchema, $i as anthropicSettings, $n as supportsBalanceCheck, $r as imageTypeMapping, $t as azureGroupConfigsSchema, Aa as googleSettings, Ai as AuthType, An as isRemoteOidcUrlAllowed, Ao as extractEnvVariable, Ar as applicationMimeTypes, At as SKILL_SYNC_DEFAULT_DISCOVERY_DEPTH, B as MutationKeys, Ba as isParamEndpoint, Bi as ReasoningEffort, Bn as paramDefinitionSchema, Br as defaultSTTMimeTypes, Bt as SettingsViews, Ca as endpointSettings, Ci as OptionTypes, Cn as getConfigDefaults, Co as feedbackRatingSchema, Cr as FileSources, Ct as MAX_SUBAGENT_DEPTH, Da as googleBaseSchema, Di as generateOpenAISchema, Dn as imageGenTools, Do as getTagsForRating, Dr as loginPage, Dt as RateLimitPrefix, Ea as getSettingsKeys, Ei as generateGoogleSchema, En as getSchemaDefaults, Eo as getTagByKey, Er as buildLoginRedirectUrl, Et as OCRStrategy, F as request_default, Fa as isAssistantsEndpoint, Fi as ImageVisionTool, Fn as modelConfigSchema, Fr as codeInterpreterMimeTypes, Ft as SafeSearchTypes, G as PrincipalType, Ga as openRouterSchema, Gi as ThinkingDisplay, Gn as setMessageFilterRegexValidator, Gr as excelMimeTypes, Gt as VisionModes, H as AccessRoleIds, Ha as openAIBaseSchema, Hi as ReasoningParameterFormat, Hn as rateLimitSchema, Hr as documentParserMimeTypes, Ht as TTSProviders, I as getTokenHeader, Ia as isDocumentSupportedProvider, Ii as MYTHOS_CLASS_FAMILIES, In as modularEndpoints, Ir as codeInterpreterMimeTypesList, It as ScraperProviders, J as accessRoleToPermBits, Ja as tBannerSchema, Ji as agentsBaseSchema, Jn as specialVariables, Jr as fullMimeTypesList, Jt as alternateName, K as ResourceType, Ka as paramEndpoints, Ki as ThinkingLevel, Kn as skillSyncConfigSchema, Kr as fileConfig, Kt as agentsEndpointSchema, L as setAcceptLanguageHeader, La as isImageVisionTool, Li as MemoryScope, Ln as normalizeMCPToolKey, Lr as codeTypeMapping, Lt as SearchCategories, Ma as imageDetailValue, Mi as BedrockReasoningConfig, Mn as memorySchema, Mo as isSensitiveEnvVar, Mr as bedrockDocumentExtensions, Mt as SKILL_SYNC_MAX_INTERVAL_MINUTES, Na as inputTokensIncludesCache, Ni as EModelEndpoint, Nn as messageFilterPiiSchema, No as normalizeEndpointName, Nr as bedrockDocumentFormats, Nt as SKILL_SYNC_MIN_INTERVAL_MINUTES, Oa as googleGenConfigSchema, Oi as validateSettingDefinitions, On as initialModelsConfig, Oo as toMinimalFeedback, Or as registerPage, Ot as RerankerTypes, Pa as isAgentsEndpoint, Pi as ImageDetail, Pn as messageFilterSchema, Pr as bedrockDocumentMimeTypes, Pt as STTProviders, Q as permBitsToAccessLevel, Qa as tExampleSchema, Qi as anthropicSchema, Qn as summarizationTriggerSchema, Qr as imageMimeTypes, Qt as azureEndpointSchema, R as setTokenHeader, Ra as isMythosClassModel, Ri as Providers, Rn as normalizeServerName, Rr as convertStringsToRegex, Rt as SearchProviders, Sa as eVerbositySchema, Si as ComponentTypes, Sn as fileStrategiesSchema, So as FEEDBACK_TAGS, Sr as FileContext, St as LocalStorageKeys, Ta as getModelKey, Ti as generateDynamicSchema, Tn as getEndpointField, To as feedbackTagKeySchema, Tr as apiBaseUrl, Tt as MAX_SUBAGENT_RUN_CONFIGS, U as PermissionBits, Ua as openAISchema, Ui as ReasoningResponseKey, Un as resolveEndpointType, Ur as endpointFileConfigSchema, Ut as Time, V as QueryKeys, Va as isUUID, Vi as ReasoningMode, Vn as providerEndpointMap, Vr as defaultTextMimeTypes, Vt as SystemCategories, W as PrincipalModel, Wa as openAISettings, Wi as ReasoningSummary, Wn as retainRecentConfigSchema, Wr as excelFileTypes, Wt as ViolationTypes, X as getResourcePermissionsResponseSchema, Xa as tConversationTagSchema, Xi as agentsSettings, Xn as splitToolCallName, Xr as getEndpointFileConfig, Xt as assistantEndpointSchema, Y as effectivePermissionsResponseSchema, Ya as tConversationSchema, Yi as agentsSchema, Yn as splitMCPToolKey, Yr as getConfiguredMimeAccept, Yt as anthropicEndpointSchema, Z as hasPermissions, Za as tConvoUpdateSchema, Zi as anthropicBaseSchema, Zn as summarizationConfigSchema, Zr as imageExtRegex, Zt as azureBaseSchema, _a as eReasoningParameterFormatSchema, _i as getRefillEligibilityDate, _n as defaultSocialLogins, _o as hostImageIdSuffix, _r as StreamableHTTPOptionsSchema, _t as FetchTokenConfig, a as data_service_exports, aa as compactAgentsSchema, ai as mbToBytes, an as bedrockModels, ao as tSharedLinkSchema, ar as turnstileSchema, at as AgentCapabilities, ba as eThinkingDisplaySchema, bi as tModelSpecSchema, bn as fileSourceSchema, bo as FEEDBACK_RATINGS, br as AuthorizationTypeEnum, bt as InfiniteCollections, ca as defaultAgentFormValues, ci as mimeTypeAliases, cn as checkpointerTypeSchema, co as EToolResources, cr as vertexModelConfigSchema, ct as BASE_PRINCIPAL_CONFIG_SECTIONS, da as eAnthropicEffortSchema, di as setFileConfigRegexCompiler, dn as contextPruningSchema, do as RunStatus, dr as MCPOptionsSchema, dt as CohereConstants, ea as assistantSchema, ei as inferMimeType, en as azureGroupSchema, eo as tModelSpecPresetSchema, er as toolApprovalHookConfigSchema, et as principalSchema, fa as eImageDetailSchema, fi as supportedMimeTypes, fn as defaultAgentCapabilities, fo as StepStatus, fr as MCPServerUserInputSchema, ft as Constants, ga as eReasoningModeSchema, gi as REFILL_INTERVAL_UNITS, gn as defaultRetrievalModels, go as defaultOrderQuery, gr as StdioOptionsSchema, gt as ErrorTypes, ha as eReasoningEffortSchema, hi as videoMimeTypes, hn as defaultModels, ho as actionDomainSeparator, hr as SSEOptionsSchema, ht as EndpointURLs, ia as compactAgentsBaseSchema, ii as isPermissiveMimeConfig, in as bedrockGuardrailConfigSchema, io as tQueryParamsSchema, ir as turnstileOptionsSchema, it as AUTH_USER_DOC_BY_ID_PREFIX, ja as imageDetailNumeric, ji as BedrockProviders, jn as langfuseConfigSchema, jo as extractVariableName, jr as audioMimeTypes, jt as SKILL_SYNC_MAX_DISCOVERY_DEPTH, ka as googleSchema, ki as AnthropicEffort, kn as interfaceSchema, ko as envVarRegex, kr as sharedFileDownload, kt as RetentionMode, la as defaultAssistantFormValues, li as retrievalMimeTypes, ln as cloudfrontConfigSchema, lo as FilePurpose, lr as visionModels, lt as CacheKeys, ma as eReasoningContextSchema, mi as textMimeTypes, mn as defaultEndpoints, mo as actionDelimiter, mr as MCP_USER_INPUT_FIELDS, mt as EImageOutputType, na as cacheSubsetProviders, ni as isAnthropicTextDocumentType, nn as baseEndpointSchema, no as tPluginSchema, nr as toolApprovalPolicySchema, nt as updateResourcePermissionsRequestSchema, oa as compactAssistantSchema, oi as megabyte, on as buildServerNameAliases, oo as AnnotationTypes, or as validateVisionModel, ot as AuthKeys, pa as eModelEndpointSchema, pi as supportsFiles, pn as defaultAssistantsVersion, po as Tools, pr as MCPServersSchema, pt as DEFAULT_MEMORY_MAX_INPUT_TOKENS, q as accessRoleSchema, qa as removeNullishValues, qi as Verbosity, qn as skillSyncGitHubSourceSchema, qr as fileConfigSchema, qt as allowedAddressesSchema, ra as coerceNumber, ri as isBedrockDocumentType, rn as bedrockEndpointSchema, ro as tPresetSchema, rr as transactionsSchema, rt as updateResourcePermissionsResponseSchema, sa as compactGoogleSchema, si as mergeFileConfig, sn as checkpointerSchema, so as AssistantStreamEvents, sr as vertexAISchema, st as BASE_ONLY_CONFIG_SECTIONS, ta as authTypeSchema, ti as isAnthropicDocumentType, tn as balanceSchema, to as tPluginAuthConfigSchema, tr as toolApprovalModeSchema, tt as resourcePermissionsResponseSchema, ua as documentSupportedProviders, ui as retrievalMimeTypesList, un as configSchema, uo as MessageContentTypes, ur as webSearchSchema, ut as Capabilities, va as eReasoningResponseKeySchema, vi as modelSpecSubagentsSchema, vn as endpointSchema, vo as hostImageNamePrefix, vr as WebSocketOptionsSchema, vt as ForkOptions, wa as extendedModelEndpointSchema, wi as SettingTypes, wn as getDefaultParamsEndpoint, wo as feedbackSchema, wr as checkOpenAIStorage, wt as MAX_SUBAGENT_GRAPH_NODES, xa as eThinkingLevelSchema, xi as MAX_SUBAGENTS, xn as fileStorageSchema, xo as FEEDBACK_REASON_KEYS, xr as TokenExchangeMethodEnum, xt as KnownEndpoints, ya as eReasoningSummarySchema, yi as specsConfigSchema, yn as excludedKeys, yo as isActionTool, yr as AuthTypeEnum, yt as ImageDetailCost, z as DynamicQueryKeys, za as isOpenAILikeProvider, zi as ReasoningContext, zn as ocrSchema, zr as defaultOCRMimeTypes, zt as SettingsTabValues } from "./data-service-pwrlWjJs.mjs";
+import { $ as permissionEntrySchema, $a as eAnthropicEffortSchema, $i as specsConfigSchema, $n as ocrSchema, $o as tQueryParamsSchema, $r as registerPage, $s as MAX_PII_CUSTOM_REGEX_INSTRUCTIONS, $t as alternateName, Aa as ReasoningResponseKey, Ac as skillFilterFieldSchema, Ai as isAnthropicTextDocumentType, An as fileStrategiesSchema, Ao as isMythosClassModel, Ar as MAX_MCP_ICON_PATH_LENGTH, As as getTagByKey, At as MAX_SUBAGENT_RUN_CONFIGS, B as MutationKeys, Ba as anthropicSchema, Bi as resolveUseResponsesApi, Bn as isSpeechProviderConfigured, Bo as removeNullishValues, Br as WebSocketOptionsSchema, Bs as isCodeWorkspaceSelection, Bt as SafeSearchTypes, Ca as MYTHOS_CLASS_FAMILIES, Cc as hasActiveFiltersConfig, Ci as getDocumentFileExtension, Cn as defaultModels, Co as inputTokensIncludesCache, Cr as turnstileOptionsSchema, Cs as resolveCodePermissionDecision, Ct as KnownEndpoints, Da as ReasoningEffort, Dc as messageFilterFieldSchema, Di as imageTypeMapping, Dn as excludedKeys, Do as isImageVisionTool, Dr as vertexModelConfigSchema, Ds as feedbackRatingSchema, Dt as LocalStorageKeys, Ea as ReasoningContext, Ec as memoryFilterFieldSchema, Ei as imageMimeTypes, En as endpointSchema, Eo as isDocumentSupportedProvider, Er as vertexAISchema, Es as FEEDBACK_TAGS, Et as LANGFUSE_TRACE_USER_METADATA_FIELDS, F as request_default, Fa as Verbosity, Fc as extractEnvVariable, Fi as mbToBytes, Fn as imageGenTools, Fo as openAIBaseSchema, Fr as MCP_SERVER_TITLE_PATTERN, Fs as CODE_WORKSPACE_ID_PATTERN, Ft as SKILL_SYNC_DEFAULT_DISCOVERY_DEPTH, G as PrincipalType, Ga as coerceNumber, Gi as supportsFiles, Gn as memorySchema, Go as tConversationTagSchema, Gr as AuthorizationTypeEnum, Gs as CONVERSATION_STARTER_FILTER_FIELDS, Gt as SettingsViews, H as AccessRoleIds, Ha as assistantSchema, Hi as retrievalMimeTypesList, Hn as langfuseTraceConfigSchema, Ho as subagentThreadLineageSchema, Hr as isProcessMCPServerConfig, Hs as isCodeWorkspaceSelections, Ht as SearchCategories, I as getTokenHeader, Ia as agentsBaseSchema, Ic as extractVariableName, Ii as megabyte, In as initialModelsConfig, Io as openAISchema, Ir as MCP_USER_INPUT_FIELDS, Is as CODE_WORKSPACE_MAX_COUNT, It as SKILL_SYNC_MAX_DISCOVERY_DEPTH, J as accessRoleToPermBits, Ja as compactAssistantSchema, Ji as REFILL_INTERVAL_UNITS, Jn as modelConfigSchema, Jo as tMessageSchema, Jr as FileSources, Js as FILE_FILTER_FIELDS, Jt as Time, K as ResourceType, Ka as compactAgentsBaseSchema, Ki as textMimeTypes, Kn as messageFilterPiiSchema, Ko as tConvoUpdateSchema, Kr as TokenExchangeMethodEnum, Ks as CONVERSATION_TITLE_FILTER_FIELDS, Kt as SystemCategories, L as setAcceptLanguageHeader, La as agentsSchema, Lc as isSensitiveEnvVar, Li as mergeFileConfig, Ln as interfaceSchema, Lo as openAISettings, Lr as SSEOptionsSchema, Ls as CODE_WORKSPACE_OPERATIONS, Lt as SKILL_SYNC_MAX_INTERVAL_MINUTES, Ma as SkillsScope, Mc as unattributedAssistantContentSchema, Mi as isMessageFileUpload, Mn as getDefaultParamsEndpoint, Mo as isParamEndpoint, Mr as MCPServerUserInputSchema, Ms as toMinimalFeedback, Mt as RateLimitPrefix, Na as ThinkingDisplay, Nc as userSubmittedMessageFieldPathSchema, Ni as isPermissiveMimeConfig, Nn as getEndpointField, No as isUUID, Nr as MCPServersSchema, Ns as CODE_ENVIRONMENT_DECISION_VERSION, Nt as RerankerTypes, Oa as ReasoningMode, Oc as modelParameterFilterFieldSchema, Oi as inferMimeType, On as fileSourceSchema, Oo as isKnownProviderIdentifier, Or as visionModels, Os as feedbackSchema, Ot as MAX_SUBAGENT_DEPTH, Pa as ThinkingLevel, Pc as envVarRegex, Pi as isResponsesApiUpload, Pn as getSchemaDefaults, Po as mediaSupportedProviders, Pr as MCP_SERVER_TITLE_ERROR, Ps as CODE_ENVIRONMENT_MODES, Pt as RetentionMode, Q as permBitsToAccessLevel, Qa as documentSupportedProviders, Qi as resolveModelSpecEndpoint, Qn as normalizeServerName, Qo as tPresetSchema, Qr as loginPage, Qs as MAX_PII_CUSTOM_REGEX_CHARACTERS, Qt as allowedAddressesSchema, R as setTokenHeader, Ra as agentsSettings, Rc as normalizeEndpointName, Ri as mimeTypeAliases, Rn as isRemoteOidcUrlAllowed, Ro as openRouterSchema, Rr as StdioOptionsSchema, Rs as CODE_WORKSPACE_SELECTION_ERROR_REASONS, Rt as SKILL_SYNC_MIN_INTERVAL_MINUTES, Sa as ImageVisionTool, Sc as getPiiRegexProgramSize, Si as getConfiguredMimeAccept, Sn as defaultEndpoints, So as imageDetailValue, Sr as transactionsSchema, Ss as resolveCodeApprovalMode, St as InfiniteCollections, Ta as Providers, Tc as hasActivePiiPatterns, Ti as imageExtRegex, Tn as defaultSocialLogins, To as isAssistantsEndpoint, Tr as validateVisionModel, Ts as FEEDBACK_REASON_KEYS, Tt as LANGFUSE_TRACE_USER_ID_FIELDS, U as PermissionBits, Ua as authTypeSchema, Ui as setFileConfigRegexCompiler, Un as listConfiguredSpeechProviders, Uo as tBannerSchema, Ur as isProcessMCPServerField, Us as ACTION_METADATA_FILTER_FIELDS, Ut as SearchProviders, V as QueryKeys, Va as anthropicSettings, Vi as retrievalMimeTypes, Vn as langfuseConfigSchema, Vo as resolveAgentSkillsScope, Vr as hasProcessMCPServerConfig, Vs as isCodeWorkspaceSelectionErrorReason, Vt as ScraperProviders, W as PrincipalModel, Wa as cacheSubsetProviders, Wi as supportedMimeTypes, Wn as mcpRefreshDefaults, Wo as tConversationSchema, Wr as AuthTypeEnum, Ws as AGENT_INSTRUCTION_FILTER_FIELDS, Wt as SettingsTabValues, X as getResourcePermissionsResponseSchema, Xa as defaultAgentFormValues, Xi as materializeModelSpecEndpoints, Xn as normalizeMCPToolKey, Xo as tPluginAuthConfigSchema, Xr as apiBaseUrl, Xs as HITL_MESSAGE_FILTER_FIELDS, Xt as VisionModes, Y as effectivePermissionsResponseSchema, Ya as compactGoogleSchema, Yi as getRefillEligibilityDate, Yn as modularEndpoints, Yo as tModelSpecPresetSchema, Yr as checkOpenAIStorage, Ys as FILTER_PII_STARTER_PATTERNS, Yt as ViolationTypes, Z as hasPermissions, Za as defaultAssistantFormValues, Zi as modelSpecSubagentsSchema, Zn as normalizeSearxngEngines, Zo as tPluginSchema, Zr as buildLoginRedirectUrl, Zs as MAX_PII_CUSTOM_PATTERNS_TOTAL, Zt as agentsEndpointSchema, _a as AuthType, _c as filterPiiActionSchema, _i as excelFileTypes, _n as codeEnvironmentUserSettingsSchema, _o as googleBaseSchema, _r as toolApprovalHookConfigSchema, _s as resolveAllowedStatefulCodeEnvironments, _t as EndpointURLs, a as data_service_exports, aa as MAX_SUBAGENTS_CEILING, ac as MESSAGE_FILTER_FIELDS, ai as bedrockDocumentFormats, an as azureGroupSchema, ao as eReasoningParameterFormatSchema, ar as retainRecentConfigSchema, as as MessageContentTypes, at as AgentCapabilities, ba as EModelEndpoint, bc as filterPiiStarterPatternSchema, bi as fileConfigSchema, bn as defaultAgentCapabilities, bo as googleSettings, br as traceViewerDefaults, bs as CodeApprovalModeError, bt as ForkOptions, ca as ComponentTypes, cc as SKILL_FILTER_FIELDS, ci as codeInterpreterMimeTypesList, cn as bedrockEndpointSchema, co as eThinkingDisplaySchema, cr as skillSyncGitHubSourceSchema, cs as Tools, ct as BASE_PRINCIPAL_CONFIG_SECTIONS, da as clampSettingRange, dc as actionMetadataFilterFieldSchema, di as defaultLLMDeliveryPathSchema, dn as buildServerNameAliases, do as endpointSettings, dr as splitToolCallName, ds as agentGitIdentitySchema, dt as CacheKeys, ea as tModelSpecSchema, ec as MAX_PII_PATTERNS_PER_SOURCE, ei as sharedFileDownload, en as anthropicEndpointSchema, eo as eImageDetailSchema, er as paramDefinitionSchema, es as tSharedLinkSchema, et as principalSchema, fa as generateDynamicSchema, fc as agentInstructionFilterFieldSchema, fi as defaultOCRMimeTypes, fn as checkpointerSchema, fo as extendedModelEndpointSchema, fr as stripServerNamePrefix, fs as defaultOrderQuery, ft as Capabilities, ga as AnthropicEffort, gc as fileFilterFieldSchema, gi as endpointFileConfigSchema, gn as codeEnvironmentUserConfigSchema, go as getSettingsKeys, gr as supportsBalanceCheck, gs as STATEFUL_CODE_ENVIRONMENTS, gt as EImageOutputType, ha as validateSettingDefinitions, hc as feedbackFilterFieldSchema, hi as documentParserMimeTypes, hn as codeEnvironmentPermissionDecisionSchema, ho as getModelKey, hr as summarizationTriggerSchema, hs as isActionTool, ht as DEFAULT_MEMORY_MAX_INPUT_TOKENS, ia as MAX_SUBAGENTS, ic as MEMORY_FILTER_FIELDS, ii as bedrockDocumentExtensions, in as azureGroupConfigsSchema, io as eReasoningModeSchema, ir as resolveTraceViewerConfig, is as FilePurpose, it as AUTH_USER_DOC_BY_ID_PREFIX, ja as ReasoningSummary, jc as toolArgumentFilterFieldSchema, ji as isBedrockDocumentType, jn as getConfigDefaults, jo as isOpenAILikeProvider, jr as MCPOptionsSchema, js as getTagsForRating, jt as OCRStrategy, ka as ReasoningParameterFormat, kc as promptFilterFieldSchema, ki as isAnthropicDocumentType, kn as fileStorageSchema, ko as isMediaSupportedProvider, kr as webSearchSchema, ks as feedbackTagKeySchema, kt as MAX_SUBAGENT_GRAPH_NODES, la as OptionTypes, lc as STORED_MESSAGE_FILTER_FIELDS, li as codeTypeMapping, ln as bedrockGuardrailConfigSchema, lo as eThinkingLevelSchema, lr as specialVariables, ls as actionDelimiter, lt as CODE_ENVIRONMENT_COMMAND_TIMEOUT_DEFAULT_MS, ma as generateOpenAISchema, mc as conversationTitleFilterFieldSchema, mi as defaultTextMimeTypes, mn as cloudfrontConfigSchema, mo as getGoogleThinkingBudgetMax, mr as summarizationConfigSchema, ms as hostImageNamePrefix, mt as Constants, na as MAX_CHAT_PROJECT_NAME_LENGTH, nc as MAX_PII_PATTERN_LABEL_LENGTH, ni as applicationMimeTypes, nn as azureBaseSchema, no as eReasoningContextSchema, nr as rateLimitSchema, ns as AssistantStreamEvents, nt as updateResourcePermissionsRequestSchema, oa as getMaxSubagents, oc as MODEL_PARAMETER_FILTER_FIELDS, oi as bedrockDocumentMimeTypes, on as balanceSchema, oo as eReasoningResponseKeySchema, or as setMessageFilterRegexValidator, os as RunStatus, ot as AuthKeys, pa as generateGoogleSchema, pc as conversationStarterFilterFieldSchema, pi as defaultSTTMimeTypes, pn as checkpointerTypeSchema, po as getGoogleThinkingBudgetBounds, pr as stripServerNamePrefixes, ps as hostImageIdSuffix, pt as CohereConstants, q as accessRoleSchema, qa as compactAgentsSchema, qi as videoMimeTypes, qn as messageFilterSchema, qo as tExampleSchema, qr as FileContext, qs as FEEDBACK_FILTER_FIELDS, qt as TTSProviders, ra as MAX_GRAPH_SUBAGENT_MEMBERS, rc as MAX_PII_PATTERN_LENGTH, ri as audioMimeTypes, rn as azureEndpointSchema, ro as eReasoningEffortSchema, rr as resolveEndpointType, rs as EToolResources, rt as updateResourcePermissionsResponseSchema, sa as setMaxSubagents, sc as PROMPT_FILTER_FIELDS, si as codeInterpreterMimeTypes, sn as baseEndpointSchema, so as eReasoningSummarySchema, sr as skillSyncConfigSchema, ss as StepStatus, st as BASE_ONLY_CONFIG_SECTIONS, ta as MAX_CHAT_PROJECT_DESCRIPTION_LENGTH, tc as MAX_PII_PATTERN_ID_LENGTH, ti as DefaultLLMDeliveryPath, tn as assistantEndpointSchema, to as eModelEndpointSchema, tr as providerEndpointMap, ts as AnnotationTypes, tt as resourcePermissionsResponseSchema, ua as SettingTypes, uc as TOOL_ARGUMENT_FILTER_FIELDS, ui as convertStringsToRegex, un as bedrockModels, uo as eVerbositySchema, ur as splitMCPToolKey, us as actionDomainSeparator, ut as CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS, va as BedrockProviders, vc as filterPiiCustomPatternSchema, vi as excelMimeTypes, vn as configSchema, vo as googleGenConfigSchema, vr as toolApprovalModeSchema, vs as resolveStatefulCodeEnvironment, vt as ErrorTypes, wa as MemoryScope, wc as hasActivePiiFields, wi as getEndpointFileConfig, wn as defaultRetrievalModels, wo as isAgentsEndpoint, wr as turnstileSchema, ws as FEEDBACK_RATINGS, wt as LANGFUSE_TRACE_CONVERSATION_METADATA_FIELDS, xa as ImageDetail, xc as filtersConfigSchema, xi as fullMimeTypesList, xn as defaultAssistantsVersion, xo as imageDetailNumeric, xr as traceViewerLimits, xs as getAllowedCodeApprovalModes, xt as ImageDetailCost, ya as BedrockReasoningConfig, yc as filterPiiRegexSchema, yi as fileConfig, yn as contextPruningSchema, yo as googleSchema, yr as toolApprovalPolicySchema, ys as CODE_APPROVAL_MODES, yt as FetchTokenConfig, z as DynamicQueryKeys, za as anthropicBaseSchema, zi as resolveSandboxFilename, zn as isSecureCodeEnvironmentControlURL, zo as paramEndpoints, zr as StreamableHTTPOptionsSchema, zs as isCodeEnvironmentMode, zt as STTProviders } from "./data-service-Bx6IFaSa.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";
@@ -184,6 +185,17 @@ function supportsContext1m(model) {
 	return false;
 }
 /**
+* Checks whether a native Anthropic Claude model supports prompt caching.
+*
+* This uses the configured model ID directly. Resolving it through a token
+* map first can collapse a newly released Claude model to the generic
+* `claude-` fallback and incorrectly disable cache control.
+*/
+function supportsPromptCache(model) {
+	if (model.includes("claude-3-5-sonnet-latest") || model.includes("claude-3.5-sonnet-latest")) return false;
+	return /claude-3[-.]7/.test(model) || /claude-3[-.]5-(?:sonnet|haiku)/.test(model) || /claude-3-(?:sonnet|haiku|opus)?/.test(model) || /claude-(?:sonnet|opus|haiku)[-.]?(?:[4-9]|\d{2,})/.test(model) || /claude-(?:[4-9]|\d{2,})(?:[-.](?:sonnet|opus|haiku))?/.test(model) || 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).
@@ -638,11 +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). */
@@ -683,6 +698,17 @@ 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;
+}({});
+const finiteNonNegativeInteger = (value) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	return Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(value)));
+};
 /**
 * Full prompt token count for one completed model call — the EXACT context the
 * model saw, provider-aware: additive providers (Bedrock) report `input_tokens`
@@ -694,37 +720,114 @@ let ActivityLabelEvents = /* @__PURE__ */ function(ActivityLabelEvents) {
 * gauge reconciles its calibrated estimate to.
 */
 const promptTokensFromUsage = (event) => {
-	const input = event.input_tokens ?? 0;
+	const input = finiteNonNegativeInteger(event.input_tokens) ?? 0;
 	const details = event.input_token_details ?? {};
-	const cacheRead = details.cache_read ?? 0;
-	const cacheCreation = details.cache_creation ?? 0;
-	return (event.provider != null ? inputTokensIncludesCache(event.provider) : cacheRead + cacheCreation <= input) ? input : input + cacheRead + cacheCreation;
+	const cacheRead = finiteNonNegativeInteger(details.cache_read) ?? 0;
+	const cacheCreation = finiteNonNegativeInteger(details.cache_creation) ?? 0;
+	return (event.provider != null ? inputTokensIncludesCache(event.provider) : cacheRead + cacheCreation <= input) ? input : Math.min(Number.MAX_SAFE_INTEGER, input + cacheRead + cacheCreation);
+};
+/**
+* Scales per-tool result-message counts while bounding both malformed input and
+* rounding error. Null-prototype records keep tool names as ordinary data keys;
+* cumulative apportionment preserves the scaled sum in one linear pass.
+*/
+const scaleToolMessageTokenCounts = (value, oldTotal, newTotal) => {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return;
+	const scaled = Object.create(null);
+	let remaining = oldTotal;
+	let cumulative = 0;
+	let allocated = 0;
+	let found = false;
+	for (const [name, rawCount] of Object.entries(value)) {
+		const count = finiteNonNegativeInteger(rawCount);
+		if (count == null || count === 0) continue;
+		const bounded = Math.min(count, remaining);
+		remaining -= bounded;
+		cumulative += bounded;
+		const target = oldTotal > 0 ? Math.round(cumulative / oldTotal * newTotal) : 0;
+		const apportioned = target - allocated;
+		allocated = target;
+		if (apportioned > 0) {
+			scaled[name] = apportioned;
+			found = true;
+		}
+	}
+	return found ? scaled : void 0;
 };
 /**
 * Reconciles a pre-invoke context snapshot's CALIBRATED estimate to a call's
 * ACTUAL prompt tokens. The SDK's calibration multiplier scales only
-* `messageTokens` (instructions/summary are raw tiktoken counts), and it can
+* `messageTokens` (instructions/summary are raw tiktoken counts) and can
 * over-shoot badly when a provider injects server-side content the SDK never
 * counted (e.g. Anthropic web search) — pinning the gauge several× too high and
 * persisting it. Trust the provider's own prompt count: keep the raw
-* instruction/summary rows, set `messageTokens` to the remainder, and recompute
-* the free space. No-op when `promptTokens` is unusable.
+* instruction/summary rows, set `messageTokens` to the remainder, recompute the
+* free space, and rescale the `toolMessageTokens` share to the new message
+* total. No-op when `promptTokens` is unusable.
 */
 const reconcileContextUsage = (snapshot, promptTokens) => {
 	if (!Number.isFinite(promptTokens) || promptTokens <= 0) return snapshot;
+	const normalizedPromptTokens = Math.min(Number.MAX_SAFE_INTEGER, Math.floor(promptTokens));
+	if (normalizedPromptTokens <= 0) return snapshot;
 	const { breakdown } = snapshot;
-	const budget = snapshot.contextBudget ?? breakdown.maxContextTokens;
-	const nonMessageTokens = (breakdown.instructionTokens ?? 0) + (breakdown.summaryTokens ?? 0);
-	const messageTokens = Math.max(0, promptTokens - nonMessageTokens);
-	return {
+	const instructionTokens = finiteNonNegativeInteger(breakdown.instructionTokens) ?? 0;
+	const summaryTokens = finiteNonNegativeInteger(breakdown.summaryTokens) ?? 0;
+	const budget = finiteNonNegativeInteger(snapshot.contextBudget) ?? finiteNonNegativeInteger(breakdown.maxContextTokens);
+	const nonMessageTokens = instructionTokens + summaryTokens;
+	const messageTokens = Math.max(0, normalizedPromptTokens - nonMessageTokens);
+	/** `toolMessageTokens` is a subset of the OLD (calibrated) `messageTokens`;
+	* rescale it by the same proportion so the split tracks the provider's real
+	* total. A supplied zero remains a known-zero split; absent fields stay absent
+	* for older snapshots. */
+	const priorMessageTokens = finiteNonNegativeInteger(breakdown.messageTokens) ?? 0;
+	const priorToolMessageTokens = finiteNonNegativeInteger(breakdown.toolMessageTokens);
+	let toolMessageTokens;
+	if (priorToolMessageTokens != null) {
+		toolMessageTokens = 0;
+		if (priorMessageTokens > 0 && priorToolMessageTokens > 0) toolMessageTokens = Math.min(messageTokens, Math.round(Math.min(priorToolMessageTokens, priorMessageTokens) / priorMessageTokens * messageTokens));
+	}
+	const toolMessageTokenCounts = toolMessageTokens != null ? scaleToolMessageTokenCounts(breakdown.toolMessageTokenCounts, Math.min(priorToolMessageTokens ?? 0, priorMessageTokens), toolMessageTokens) : void 0;
+	const nextBreakdown = {
+		...breakdown,
+		instructionTokens,
+		summaryTokens,
+		messageTokens
+	};
+	if (toolMessageTokens == null) {
+		delete nextBreakdown.toolMessageTokens;
+		delete nextBreakdown.toolMessageTokenCounts;
+	} else {
+		nextBreakdown.toolMessageTokens = toolMessageTokens;
+		if (toolMessageTokenCounts == null) delete nextBreakdown.toolMessageTokenCounts;
+		else nextBreakdown.toolMessageTokenCounts = toolMessageTokenCounts;
+	}
+	const result = {
 		...snapshot,
-		breakdown: {
-			...breakdown,
-			messageTokens
-		},
-		remainingContextTokens: budget != null ? Math.max(0, budget - promptTokens) : snapshot.remainingContextTokens
+		breakdown: nextBreakdown
 	};
+	if (budget != null) result.remainingContextTokens = Math.max(0, budget - normalizedPromptTokens);
+	else {
+		const remaining = finiteNonNegativeInteger(snapshot.remainingContextTokens);
+		if (remaining == null) delete result.remainingContextTokens;
+		else result.remainingContextTokens = remaining;
+	}
+	return result;
 };
+/** Provider output, including reasoning omitted from an under-reported output count. */
+const outputTokensFromUsage = (event) => {
+	const output = finiteNonNegativeInteger(event.output_tokens) ?? 0;
+	const total = finiteNonNegativeInteger(event.total_tokens) ?? 0;
+	return Math.max(output, total - promptTokensFromUsage(event));
+};
+/** Reconcile and retain the primary call details on live, saved, and resumable snapshots. */
+const reconcileContextUsageFromEvent = (snapshot, event) => ({
+	...reconcileContextUsage(snapshot, promptTokensFromUsage(event)),
+	model: event.model,
+	provider: event.provider,
+	completedOutputTokens: outputTokensFromUsage(event),
+	cacheRead: finiteNonNegativeInteger(event.input_token_details?.cache_read) ?? 0,
+	cacheWrite: finiteNonNegativeInteger(event.input_token_details?.cache_creation) ?? 0
+});
 //#endregion
 //#region src/parsers.ts
 dayjs.extend(utc);
@@ -958,6 +1061,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.
 *
@@ -1249,7 +1360,266 @@ 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/resolve-llm-delivery-path.ts
+/** Audio and video reach the model only through the media encoders, which support a
+*  narrower provider set than documents. Images use the broadly supported vision
+*  path and are never gated here. */
+const isProviderCapable = (mimeType, endpoint, useResponsesApi) => {
+	if (mimeType.startsWith("audio/") || mimeType.startsWith("video/")) return isMediaSupportedProvider(endpoint);
+	if (mimeType === "application/pdf") return useResponsesApi === true || isDocumentSupportedProvider(endpoint);
+	return true;
+};
+const SYSTEM_LLM_DELIVERY_DEFAULTS = {
+	fallback: "text",
+	overrides: {
+		"image/*": "provider",
+		"video/*": "provider",
+		"audio/*": "provider",
+		"application/pdf": "provider"
+	}
+};
+/**
+* Types some step in the upload pipeline can turn into text: natively readable text,
+* documents a parser or OCR handles, images through OCR, and audio through transcription.
+*
+* Everything absent from this list, notably archives, tarballs, columnar data files and
+* video, has no such step, and the default text matcher accepts any well-formed type, so
+* routing them to text ends in their bytes being decoded as UTF-8.
+*/
+const TEXT_RECOVERABLE_MIME_TYPES = [
+	/^text\//,
+	/^image\//,
+	/^audio\//,
+	/^application\/(json|javascript|xml|sql|yaml|x-yaml|csv|typescript|x-sh|vnd\.coffeescript)$/,
+	/^application\/pdf$/,
+	/^application\/vnd\.openxmlformats-officedocument\.(wordprocessingml\.document|spreadsheetml\.sheet)$/,
+	/^application\/vnd\.oasis\.opendocument\.(text|spreadsheet)$/,
+	/^application\/(vnd\.ms-excel|x-msexcel|msexcel|x-ms-excel|x-excel|x-dos_ms_excel|xls|x-xls)$/,
+	/^message\/rfc822$/
+];
+/**
+* Types whose bytes are text already, so reading them directly is meaningful. Everything
+* else needs a real extractor: decoding it as UTF-8 produces mojibake rather than content.
+*/
+/** Application types whose payload is text. Mirrors the set the content-protection code
+*  treats as textual, plus the source and data formats this pipeline also accepts. */
+const TEXTUAL_APPLICATION_MIME_TYPES = new Set([
+	"application/json",
+	"application/javascript",
+	"application/sql",
+	"application/xml",
+	"application/x-yaml",
+	"application/yaml",
+	"application/csv",
+	"application/typescript",
+	"application/x-sh",
+	"application/vnd.coffeescript"
+]);
+function isNativelyReadableText(mimeType) {
+	const normalized = mimeType.split(";", 1)[0].trim().toLowerCase();
+	return normalized.startsWith("text/") || TEXTUAL_APPLICATION_MIME_TYPES.has(normalized) || normalized === "message/rfc822";
+}
+function hasTextExtractionPath(mimeType) {
+	return TEXT_RECOVERABLE_MIME_TYPES.some((pattern) => pattern.test(mimeType));
+}
+/**
+* Resolves the default file path destination for a given mime type.
+* Resolution chain: endpoint overrides -> endpoint fallback -> global overrides -> global fallback -> system defaults.
+*/
+function resolveDefaultLLMDeliveryPath(mimeType, endpointConfig, globalConfig, endpoint, useResponsesApi, sttConfigured) {
+	const wildcard = mimeType.split("/")[0] + "/*";
+	if (endpointConfig?.overrides) {
+		if (endpointConfig.overrides[mimeType]) return endpointConfig.overrides[mimeType];
+		if (endpointConfig.overrides[wildcard]) return endpointConfig.overrides[wildcard];
+	}
+	if (endpointConfig?.fallback) return endpointConfig.fallback;
+	if (globalConfig?.overrides) {
+		if (globalConfig.overrides[mimeType]) return globalConfig.overrides[mimeType];
+		if (globalConfig.overrides[wildcard]) return globalConfig.overrides[wildcard];
+	}
+	if (globalConfig?.fallback) return globalConfig.fallback;
+	const systemDefault = SYSTEM_LLM_DELIVERY_DEFAULTS.overrides[mimeType] ?? SYSTEM_LLM_DELIVERY_DEFAULTS.overrides[wildcard] ?? SYSTEM_LLM_DELIVERY_DEFAULTS.fallback;
+	/** Only the system default is capability-gated: an explicit config above is the
+	*  admin's decision. A known endpoint that cannot encode documents or media would
+	*  otherwise accept the upload and hand the model nothing at all. */
+	/** `agents` is a container, not a provider: it is what an upload reports when the
+	*  agent's real provider could not be resolved, as for ephemeral agents. A custom
+	*  endpoint name is likewise unresolvable here, since its real provider is chosen
+	*  at request time and is usually OpenAI- or Anthropic-compatible. Judging
+	*  capability from either would downgrade media the actual provider can deliver,
+	*  so an unresolved provider keeps the system default. */
+	const namedEndpoint = endpoint != null && endpoint !== "agents";
+	const providerKnown = namedEndpoint && isKnownProviderIdentifier(endpoint);
+	const isMedia = mimeType.startsWith("audio/") || mimeType.startsWith("video/");
+	const canRecoverText = (type) => type.startsWith("audio/") && sttConfigured === false ? false : hasTextExtractionPath(type);
+	if (systemDefault === "provider" && (isMedia ? namedEndpoint : providerKnown) && !isProviderCapable(mimeType, endpoint, useResponsesApi)) return canRecoverText(mimeType) ? "text" : "none";
+	/** Bedrock's Converse document path natively accepts more than PDF, so on that
+	*  endpoint its document types belong on the provider path rather than being
+	*  extracted, which would drop non-text content and layout. */
+	if (systemDefault !== "provider" && endpoint === "bedrock" && isBedrockDocumentType(mimeType)) return "provider";
+	if (systemDefault === "text" && !canRecoverText(mimeType)) return "none";
+	return systemDefault;
+}
+/**
+* Delivery path for an upload that named no tool resource. The legacy chooser makes the
+* destination explicit, so nothing is inferred there.
+*/
+function resolveDefaultUploadLLMDeliveryPath({ mimeType, endpointConfig, fileConfig, endpoint, useResponsesApi, sttConfigured }) {
+	if (endpointConfig?.legacyFileUploadUX === true) return "provider";
+	return resolveDefaultLLMDeliveryPath(mimeType, endpointConfig?.defaultLLMDeliveryPath, fileConfig?.defaultLLMDeliveryPath, endpoint, useResponsesApi, sttConfigured);
+}
+/** Delivery path for an upload, honoring an explicitly chosen tool resource. */
+function resolveUploadLLMDeliveryPath({ toolResource, mimeType, endpointConfig, fileConfig, endpoint, useResponsesApi, sttConfigured }) {
+	if (toolResource === "context" || toolResource === "ocr") return "text";
+	if (toolResource === "file_search" || toolResource === "execute_code") return "none";
+	return resolveDefaultUploadLLMDeliveryPath({
+		mimeType,
+		endpointConfig,
+		fileConfig,
+		endpoint,
+		useResponsesApi,
+		sttConfigured
+	});
+}
+/**
+* Whether a file tool can do anything with this type. `file_search` indexes extracted
+* text, so it needs a type some step can turn into text and cannot use media, whose
+* extraction paths are OCR and speech rather than the vector store. Code execution is
+* judged by the list the client offers it from. Shared by upload-time selection and
+* deferred provisioning so the two cannot queue a file the other would refuse.
+*/
+function canToolResourceConsume(toolResource, mimeType) {
+	if (toolResource === "file_search") return !mimeType.startsWith("image") && !mimeType.startsWith("audio") && !mimeType.startsWith("video") && (hasTextExtractionPath(mimeType) || matchesMimeList(mimeType, retrievalMimeTypes));
+	if (toolResource === "execute_code") return matchesMimeList(mimeType, codeInterpreterMimeTypes);
+	return true;
+}
+const matchesMimeList = (mimeType, patterns) => patterns.some((pattern) => pattern.test(mimeType));
+/**
+* Where a unified upload will end up, and whether it can be accepted at all.
+*
+* An upload has to be readable by something: the model, an extraction step, or a file
+* tool. A permanent one has to land on an agent resource too, or storing it succeeds
+* while leaving the agent no reference to it. Both outcomes are decided here rather than
+* discovered later, so a request that would change nothing is refused with a reason.
+*
+* `agentTools` is undefined when no agent record backs the upload, as for an ephemeral
+* agent that exists only for the request. An unknown tool set is not judged.
+*/
+function resolveUploadDestination(params) {
+	const { toolResource, deliveryPath, mimeType, agentTools, hasAgent, isMessageAttachment, allowUnknownMessageConsumer = false, contextEnabled } = params;
+	const refusesContext = (resource) => resource === "context" && hasAgent && !isMessageAttachment && contextEnabled === false;
+	if (toolResource) {
+		const resolved = toolResource === "ocr" ? "context" : toolResource;
+		return refusesContext(resolved) ? { rejection: "context-disabled" } : { toolResource: resolved };
+	}
+	if (deliveryPath === "text") return refusesContext("context") ? { rejection: "context-disabled" } : { toolResource: "context" };
+	const consumingTool = agentTools?.find((tool) => (tool === "execute_code" || tool === "file_search") && canToolResourceConsume(tool, mimeType));
+	if (deliveryPath === "none" && consumingTool) return { toolResource: consumingTool };
+	if (hasAgent && !isMessageAttachment) return { rejection: "no-agent-resource" };
+	if (deliveryPath === "none" && (!isMessageAttachment || !allowUnknownMessageConsumer)) return { rejection: "no-consumer" };
+	return {};
+}
+//#endregion
 //#region src/messages.ts
+/** A generated reasoning title describes the text as it existed at generation time.
+*  Any manual edit or merge into a different reasoning step invalidates the entire
+*  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
@@ -1260,6 +1630,11 @@ function mapGroupToAzureConfig({ groupName, groupMap }) {
 */
 function buildTree({ messages, fileMap }) {
 	if (messages === null) return null;
+	const cached = treeCache.get(messages);
+	if (cached) {
+		if (fileMap == null && cached.bare) return cached.bare;
+		if (fileMap != null && cached.fileMap === fileMap && cached.hydrated) return cached.hydrated;
+	}
 	const messageMap = {};
 	const orderedMessages = [];
 	const rootMessages = [];
@@ -1313,7 +1688,129 @@ function buildTree({ messages, fileMap }) {
 		rootMessages.push(extendedMessage);
 		assignDepths(extendedMessage);
 	}
-	return rootMessages;
+	const tree = rootMessages;
+	const entry = cached ?? {};
+	if (fileMap == null) entry.bare = tree;
+	else {
+		entry.fileMap = fileMap;
+		entry.hydrated = tree;
+	}
+	if (!cached) treeCache.set(messages, entry);
+	return tree;
+}
+/**
+* Memoizes a messages array's id index. Every row that needs to look another
+* message up (the hover controls resolving the turn a rerun would replay) would
+* otherwise scan the whole array, which is quadratic in the conversation. A
+* cache write replaces the array, so the index dies with the array it indexes
+* and can never answer from stale rows.
+*/
+const indexCache = /* @__PURE__ */ new WeakMap();
+/** The message with this id, resolved through the array's memoized index. */
+function findMessageById(messages, messageId) {
+	if (messages == null || messageId == null) return;
+	let index = indexCache.get(messages);
+	if (index == null) {
+		index = /* @__PURE__ */ new Map();
+		for (const message of messages) if (message?.messageId != null && !index.has(message.messageId)) index.set(message.messageId, message);
+		indexCache.set(messages, index);
+	}
+	return index.get(messageId);
+}
+/**
+* True when a turn carries the marker the server stamps on a manual compaction:
+* `markCompactionSummary` sets `initiatedBy: 'user'` on the summary a Compact
+* action produced, and nothing else writes it, so an automatic summary detour is
+* not one. This is the compaction's own identity, independent of where it hangs:
+* Compact runs on whatever leaf the branch ends with, so its response can parent
+* onto a user message as easily as onto the answer it summarized. Redoing one is
+* the context indicator's Compact action, never a rerun of the turn behind it.
+*/
+function isUserInitiatedCompaction(message) {
+	const content = message?.content;
+	if (!Array.isArray(content)) return false;
+	return content.some((part) => part?.type === "summary" && part.initiatedBy === "user");
+}
+/**
+* True when a message is a finished manual compaction: every content part is a
+* summary and at least one of them carries text. A part that is still streaming
+* or that failed contributes no text of its own, so an interrupted compaction
+* can be retried.
+*/
+function isCompactedLeaf(message) {
+	const content = message?.content;
+	if (!Array.isArray(content) || content.length === 0) return false;
+	let usable = false;
+	for (const part of content) {
+		if (part?.type !== "summary") return false;
+		if (part.summarizing === true || part.failed === true) continue;
+		const hasText = (part.content ?? []).some((block) => typeof block?.text === "string" && block.text.trim().length > 0);
+		usable = usable || hasText;
+	}
+	return usable;
+}
+//#endregion
+//#region src/errors.ts
+const TOOL_CALL_ERROR_PREFIX = /^Error:\s*(?:\[[^\]]*\]\s*)*tool call failed:\s*/i;
+function hasToolCallErrorPrefix(text) {
+	return TOOL_CALL_ERROR_PREFIX.test(text);
+}
+function stripToolCallErrorPrefix(text) {
+	return text.replace(TOOL_CALL_ERROR_PREFIX, "");
+}
+//#endregion
+//#region src/runSteps.ts
+/**
+* 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
@@ -4486,6 +4983,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;
 }({});
 /**
@@ -4509,11 +5010,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.
@@ -4614,6 +5124,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),
@@ -4635,7 +5149,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
@@ -4716,6 +5231,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)
 			})
 		})
 	}),
@@ -4789,6 +5308,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	},
@@ -4844,6 +5367,10 @@ const roleDefaults = defaultRolesSchema.parse({
 				["CREATE"]: true,
 				["SHARE"]: true,
 				["SHARE_PUBLIC"]: true
+			},
+			["SCHEDULES"]: {
+				["USE"]: true,
+				["CREATE"]: true
 			}
 		}
 	}
@@ -4863,6 +5390,337 @@ 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() });
+/** Only structured schedule preflight failures may request immediate suspension. */
+function getScheduleMCPDisabledReason(outcomes) {
+	const statuses = new Set(outcomes?.map((outcome) => outcome.status));
+	if (statuses.has("mcp_permission_denied")) return "mcp_permission_denied";
+	if (statuses.has("mcp_configuration_missing")) return "mcp_configuration_missing";
+	if (statuses.has("mcp_reauth_required")) return "mcp_reauth_required";
+}
+const scheduleMCPOutcomeSchema = z.object({
+	server: z.string(),
+	/** Agent whose selected tool requires this server. Used to open the correct
+	* recovery chat when the requirement belongs to a handoff or subagent. */
+	agentId: z.string().optional(),
+	status: z.enum([
+		"ready",
+		"mcp_reauth_required",
+		"mcp_configuration_missing",
+		"mcp_permission_denied",
+		"mcp_unavailable"
+	])
+});
+function readScheduleMCPOutcomes(error) {
+	if (!error || !/^mcp_(reauth_required|configuration_missing|permission_denied|unavailable): \[/.test(error)) return [];
+	try {
+		const result = scheduleMCPOutcomeSchema.array().safeParse(JSON.parse(error.slice(error.indexOf(": ") + 2)));
+		return result.success ? result.data : [];
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/cadence.ts
+/** Mirrors the server default when a weekly cadence omits `daysOfWeek`. */
+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,
@@ -4895,6 +5753,252 @@ 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;
+const INSIGHTS_AGENT_ID_MAX_LENGTH = 256;
+//#endregion
+//#region src/types/traces.ts
+const TRACE_CURSOR_MAX_LENGTH = 4096;
+const TRACE_SOURCE_ID_MAX_LENGTH = 128;
+const TRACE_RECORD_ID_MAX_LENGTH = 256;
+//#endregion
+//#region src/types/queuedTurns.ts
+const agentQueuedTurnStatuses = [
+	"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["lemonade"] = "lemonade";
+	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",
+	["lemonade"]: "lemonade",
+	["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",
+	amdlemonade: "lemonade",
+	lemonadeserver: "lemonade",
+	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/svg.ts
+/**
+* DOMPurify policy for user-provided SVG icons, shared by the browser uploader and
+* the server trust boundary so a preview and the persisted icon cannot disagree.
+* `use` is re-added for self-contained `<defs>` references (targets restricted by
+* `restrictSvgReferences`); every SMIL element is forbidden so a stored icon
+* cannot animate forever wherever it renders.
+*/
+const SVG_SANITIZE_CONFIG = {
+	USE_PROFILES: {
+		svg: true,
+		svgFilters: true
+	},
+	ADD_TAGS: ["use"],
+	ADD_ATTR: ["fr"],
+	FORBID_TAGS: [
+		"script",
+		"foreignObject",
+		"style",
+		"a",
+		"image",
+		"animate",
+		"animateColor",
+		"animateMotion",
+		"animateTransform",
+		"mpath",
+		"set"
+	],
+	FORBID_ATTR: ["style"]
+};
+const URL_TOKEN_PREFIX = /url\(\s*['"]?\s*/gi;
+/**
+* True when every `url()` token targets a fragment. Backslashes reject the value
+* outright: CSS unescapes idents before tokenizing, so `u\72l(...)` is a `url()`.
+*/
+function referencesOnlyFragments(value) {
+	if (value.includes("\\")) return false;
+	if (!value.toLowerCase().includes("url(")) return true;
+	URL_TOKEN_PREFIX.lastIndex = 0;
+	while (URL_TOKEN_PREFIX.exec(value) !== null) if (value[URL_TOKEN_PREFIX.lastIndex] !== "#") return false;
+	return true;
+}
+/** DOMPurify hook that drops every attribute referencing outside the document. */
+function restrictSvgReferences(node) {
+	const names = [];
+	for (let i = 0; i < node.attributes.length; i += 1) names.push(node.attributes[i].name);
+	for (const name of names) {
+		const value = node.getAttribute(name)?.trim();
+		if (value == null) continue;
+		if (name === "href" || name === "xlink:href") {
+			if (!value.startsWith("#")) node.removeAttribute(name);
+			continue;
+		}
+		if (!referencesOnlyFragments(value)) node.removeAttribute(name);
+	}
+}
+/** SVG names the HTML parser lowercases and its adjustment table does not restore. */
+const UNADJUSTED_SVG_TAGS = [[/(<\/?)fedropshadow\b/gi, "$1feDropShadow"]];
+const SVG_ROOT_TAG = /<svg(\s[^>]*)?>/i;
+/**
+* Makes HTML-mode sanitizer output valid as a standalone `image/svg+xml`
+* document: restores camelCase element names the HTML parser lowercased and
+* declares the SVG namespace on the root, without which an XML parser puts the
+* root in no namespace and the icon renders blank.
+*/
+function finalizeSvgMarkup(markup) {
+	let restored = markup;
+	for (const [pattern, canonical] of UNADJUSTED_SVG_TAGS) restored = restored.replace(pattern, canonical);
+	return restored.replace(SVG_ROOT_TAG, (tag, attributes) => attributes != null && /\sxmlns\s*=/i.test(attributes) ? tag : `<svg xmlns="http://www.w3.org/2000/svg"${attributes ?? ""}>`);
+}
+//#endregion
 //#region src/actions.ts
 function sha1(input) {
 	return crypto.createHash("sha1").update(input).digest("hex");
@@ -5378,11 +6482,13 @@ function getUserTimezone() {
 	}
 }
 function createPayload(submission) {
-	const { isEdited, addedConvo, userMessage, isContinued, isTemporary, isRegenerate, conversation, editedContent, ephemeralAgent, endpointOption, manualSkills, clientRequestId, recoverySteerId, expectedPredecessorCreatedAt } = submission;
+	const { isEdited, addedConvo, userMessage, isContinued, isTemporary, isRegenerate, compact, conversation, editedContent, ephemeralAgent, endpointOption, manualSkills, codeApprovalMode, codeEnvironmentMode, codeWorkspaces, clientRequestId, recoverySteerId, expectedPredecessorCreatedAt } = submission;
 	const { conversationId } = 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,
@@ -5390,12 +6496,18 @@ function createPayload(submission) {
 		endpoint,
 		addedConvo,
 		isTemporary,
-		isRegenerate,
+		/** A compaction borrows the regenerate shape client-side only: the server
+		*  must see it as a compaction, never as a regenerated user turn. */
+		isRegenerate: compact === true ? void 0 : isRegenerate,
+		...compact === true && { compact: true },
 		editedContent,
 		conversationId,
 		isContinued: !!(isEdited && isContinued),
 		ephemeralAgent: isAssistantsEndpoint(endpoint) ? void 0 : ephemeralAgent,
 		manualSkills: isAssistantsEndpoint(endpoint) ? void 0 : manualSkills,
+		codeApprovalMode: isAssistantsEndpoint(endpoint) ? void 0 : codeApprovalMode,
+		codeEnvironmentMode: isAssistantsEndpoint(endpoint) ? void 0 : codeEnvironmentMode,
+		codeWorkspaces: isAssistantsEndpoint(endpoint) ? void 0 : codeWorkspaces,
 		timezone: getUserTimezone(),
 		clientRequestId,
 		recoverySteerId,
@@ -5458,28 +6570,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) => {
@@ -5537,6 +6627,30 @@ const librechat = {
 		placeholderCode: true,
 		optionType: "model"
 	},
+	/** Controls how LibreChat encodes image content blocks, not a provider request
+	* parameter — so it belongs to this group and is stripped from model options. */
+	imageDetail: {
+		key: "imageDetail",
+		label: "com_endpoint_plug_image_detail",
+		labelCode: true,
+		description: "com_endpoint_openai_detail",
+		descriptionCode: true,
+		type: "enum",
+		default: "auto",
+		component: "slider",
+		options: [
+			"low",
+			"auto",
+			"high"
+		],
+		enumMappings: {
+			["low"]: "com_ui_low",
+			["auto"]: "com_ui_auto",
+			["high"]: "com_ui_high"
+		},
+		optionType: "conversation",
+		columnSpan: 2
+	},
 	fileTokenLimit: {
 		key: "fileTokenLimit",
 		label: "com_ui_file_token_limit",
@@ -6115,6 +7229,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: {
@@ -6254,7 +7376,7 @@ const google = {
 const googleConfig = [
 	librechat.modelLabel,
 	librechat.promptPrefix,
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -6273,7 +7395,7 @@ const googleCol1 = [
 	librechat.promptPrefix
 ];
 const googleCol2 = [
-	librechat.maxContextTokens,
+	google.maxContextTokens,
 	google.maxOutputTokens,
 	google.temperature,
 	google.topP,
@@ -6297,7 +7419,7 @@ const openAI = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.web_search,
 	openAIParams.reasoning_effort,
 	openAIParams.useResponsesApi,
@@ -6327,7 +7449,7 @@ const openAICol2 = [
 	openAIParams.presence_penalty,
 	baseDefinitions.stop,
 	librechat.resendFiles,
-	baseDefinitions.imageDetail,
+	librechat.imageDetail,
 	openAIParams.reasoning_effort,
 	openAIParams.reasoning_summary,
 	openAIParams.reasoning_mode,
@@ -6568,6 +7690,38 @@ const paramSettings = {
 	[`bedrock-zai`]: bedrockZAI,
 	["google"]: googleConfig
 };
+/**
+* Maps effective backend param names for OpenAI-compatible/Azure endpoints (as deleted from
+* `llmConfig` via `dropParams`, e.g. `maxTokens`) to their corresponding UI/conversation keys
+* (e.g. `max_tokens`). Native providers (anthropic, google, bedrock, ...) already render these
+* same camelCase names as their UI key (e.g. `topP`), so this alias must only be applied to
+* OpenAI-compatible parameter sets — see `resolveDropParamsUIKeys`.
+*/
+const dropParamsBackendToUIKey = {
+	maxTokens: "max_tokens",
+	topP: "top_p",
+	frequencyPenalty: "frequency_penalty",
+	presencePenalty: "presence_penalty"
+};
+/** Endpoint keys whose parameter settings render the OpenAI-compatible (snake_case) UI keys. */
+const openAILikeParamEndpointKeys = new Set([
+	"openAI",
+	"azureOpenAI",
+	"custom",
+	"openrouter"
+]);
+/**
+* Normalizes an admin-configured `dropParams` list into the UI/conversation keys used to hide
+* the matching controls in the settings panels. `endpointKey` should be the same key used to
+* resolve the panel's parameter settings (e.g. `overriddenEndpointKey`); the backend-name alias
+* is only applied for OpenAI-compatible endpoints, since native providers (anthropic, google,
+* bedrock, ...) already use these backend names as their UI key.
+*/
+function resolveDropParamsUIKeys(dropParams, endpointKey) {
+	if (!dropParams || dropParams.length === 0) return /* @__PURE__ */ new Set();
+	if (!openAILikeParamEndpointKeys.has(endpointKey)) return new Set(dropParams);
+	return new Set(dropParams.map((param) => dropParamsBackendToUIKey[param] ?? param));
+}
 const openAIColumns = {
 	col1: openAICol1,
 	col2: openAICol2
@@ -6634,13 +7788,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
@@ -6667,7 +7879,54 @@ 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
+//#region src/code/worker.ts
+function isCodeWorkerShell(value) {
+	return value === "posix" || value === "powershell";
+}
+function quotePosix(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function quotePowerShell(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+function createCodeWorkerSetupCommand(pairing, shell, options = {}) {
+	const quote = shell === "powershell" ? quotePowerShell : quotePosix;
+	const pair = `librechat-code pair ${quote(pairing.endpoint)} ${quote(pairing.code)} --worker-id ${quote(pairing.workerId)}`;
+	const run = ["librechat-code run", ...[
+		options.defaultWorkspace === false ? null : "--default-workspace",
+		options.allowWorkspaceWrites === true ? "--allow-workspace-writes" : null,
+		options.allowWorkspaceCommands === true ? "--allow-workspace-commands" : null
+	].filter((value) => value != null)].join(" ");
+	if (shell === "powershell") return `${pair}\n$env:LIBRECHAT_CODE_WORKER_ID = ${quote(pairing.workerId)}\n${run}`;
+	return `${pair}\nLIBRECHAT_CODE_WORKER_ID=${quote(pairing.workerId)} ${run}`;
+}
 //#endregion
-export { 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, 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, MemoryScope, MessageContentTypes, MutationKeys, OCRStrategy, OptionTypes, PERMISSION_SUB_KEYS, PERMISSION_TYPE_INTERFACE_FIELDS, PermissionBits, PermissionTypes, Permissions, PrincipalModel, PrincipalType, Providers, QueryKeys, REFILL_INTERVAL_UNITS, RateLimitPrefix, ReasoningContext, ReasoningEffort, ReasoningMode, 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, SteerEvents, 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, bedrockDocumentMimeTypes, bedrockEndpointSchema, bedrockGuardrailConfigSchema, bedrockInputParser, bedrockInputSchema, bedrockModels, bedrockOutputParser, bookmarkPermissionsSchema, breadcrumb, buildLoginRedirectUrl, buildServerNameAliases, buildTree, button, cacheSubsetProviders, calendar, capsEffortWhenThinkingDisabled, card, carousel, checkOpenAIStorage, checkbox, checkpointerSchema, checkpointerTypeSchema, clampEffortForDisabledThinking, clampOutputConfigEffort, 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, eReasoningContextSchema, eReasoningEffortSchema, eReasoningModeSchema, 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, getConfiguredMimeAccept, 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, isAnthropicDocumentType, isAnthropicTextDocumentType, isAssistantsEndpoint, isBedrockDocumentType, isDocumentSupportedProvider, isEphemeralAgentId, isImageVisionTool, isMythosClassModel, isOpenAILikeProvider, isParamEndpoint, isPermissiveMimeConfig, isRemoteOidcUrlAllowed, isSensitiveEnvVar, isSystemRoleName, isThinkingDisabled, isUUID, label, langfuseConfigSchema, librechat, loginPage, mapGroupToAzureConfig, mapModelToAzureConfig, marketplacePermissionsSchema, mbToBytes, mcpServersPermissionsSchema, megabyte, memoryPermissionsSchema, memorySchema, menuBar, mergeFileConfig, messageFilterPiiSchema, messageFilterSchema, mimeTypeAliases, modelConfigSchema, modelSpecSubagentsSchema, modularEndpoints, multiConvoPermissionsSchema, navigationMenu, normalizeEndpointName, normalizeMCPToolKey, normalizeServerName, 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, requiresExplicitThinkingDisabled, resolveEndpointType, resolveRef, resolveThinkingDisplay, resourcePermissionsResponseSchema, retainRecentConfigSchema, retrievalMimeTypes, retrievalMimeTypesList, roleDefaults, roleSchema, runCodePermissionsSchema, select, separator, setAcceptLanguageHeader, setFileConfigRegexCompiler, setMessageFilterRegexValidator, setTokenHeader, sha1, shadcnComponents, sharedFileDownload, sharedLinksPermissionsSchema, skeleton, skillPermissionsSchema, skillSyncConfigSchema, skillSyncGitHubSourceSchema, slider, specialVariables, specsConfigSchema, splitMCPToolKey, splitToolCallName, 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, toolApprovalHookConfigSchema, toolApprovalModeSchema, toolApprovalPolicySchema, 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_APPROVAL_MODES, CODE_ENVIRONMENT_COMMAND_TIMEOUT_DEFAULT_MS, CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS, CODE_ENVIRONMENT_DECISION_VERSION, CODE_ENVIRONMENT_MODES, CODE_ENV_KINDS, CODE_WORKSPACE_ID_PATTERN, CODE_WORKSPACE_MAX_COUNT, CODE_WORKSPACE_OPERATIONS, CODE_WORKSPACE_SELECTION_ERROR_REASONS, CONVERSATION_STARTER_FILTER_FIELDS, CONVERSATION_TITLE_FILTER_FIELDS, CacheKeys, Capabilities, CodeApprovalModeError, CohereConstants, ComponentTypes, Constants, ContentTypes, DATE_RANGE, DEFAULT_MEMORY_MAX_INPUT_TOKENS, DefaultLLMDeliveryPath, 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_AGENT_ID_MAX_LENGTH, INSIGHTS_MAX_RANGE_DAYS, INSIGHTS_SEARCH_MAX_LENGTH, INSIGHTS_SEARCH_MIN_LENGTH, INTERFACE_PERMISSION_FIELDS, ImageDetail, ImageDetailCost, ImageVisionTool, InfiniteCollections, InvocationMode, KnownEndpoints, LANGFUSE_TRACE_CONVERSATION_METADATA_FIELDS, LANGFUSE_TRACE_USER_ID_FIELDS, LANGFUSE_TRACE_USER_METADATA_FIELDS, LocalStorageKeys, MAX_CHAT_PROJECT_DESCRIPTION_LENGTH, MAX_CHAT_PROJECT_NAME_LENGTH, MAX_GRAPH_SUBAGENT_MEMBERS, MAX_MCP_ICON_PATH_LENGTH, 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, SVG_SANITIZE_CONFIG, SYSTEM_LLM_DELIVERY_DEFAULTS, SafeSearchTypes, ScraperProviders, SearchCategories, SearchProviders, SettingTypes, SettingsTabValues, SettingsViews, SkillsScope, StdioOptionsSchema, SteerEvents, StepEvents, StepStatus, StepTypes, StreamableHTTPOptionsSchema, SystemCategories, SystemRoles, TOOL_ARGUMENT_FILTER_FIELDS, TRACE_CURSOR_MAX_LENGTH, TRACE_RECORD_ID_MAX_LENGTH, TRACE_SOURCE_ID_MAX_LENGTH, TTSProviders, ThinkingDisplay, ThinkingLevel, Time, TokenExchangeMethodEnum, ToolCallTypes, Tools, UsageEvents, Verbosity, ViolationTypes, VisionModes, WebSocketOptionsSchema, accessRoleSchema, accessRoleToPermBits, accordian, actionDelimiter, actionDomainSeparator, actionMetadataFilterFieldSchema, agentGitIdentitySchema, 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, canToolResourceConsume, 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, createCodeWorkerSetupCommand, createPayload, createSchedulePayloadSchema, createURL, cronCadenceSchema, data_service_exports as dataService, defaultAgentCapabilities, defaultAgentFormValues, defaultAssistantFormValues, defaultAssistantsVersion, defaultEndpoints, defaultLLMDeliveryPathSchema, 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, finalizeSvgMarkup, findLastSeparatorIndex, findMessageById, fullMimeTypesList, generateDynamicSchema, generateGoogleSchema, generateOpenAISchema, getAllowedCodeApprovalModes, getCodeEnvRefForProfile, getCodeEnvRefs, getConfigDefaults, getConfiguredMimeAccept, getDefaultParamsEndpoint, getDocumentFileExtension, getEnabledEndpoints, getEndpointField, getEndpointFileConfig, getEphemeralSender, getFirstDefinedValue, getGoogleThinkingBudgetBounds, getGoogleThinkingBudgetMax, getMaxSubagents, getModelKey, getNonEmptyValue, getPiiRegexProgramSize, getRefillEligibilityDate, getResourcePermissionsResponseSchema, getResponseSender, getRunStepDurationMs, getScheduleMCPDisabledReason, getSchemaDefaults, getSettingsKeys, getTagByKey, getTagsForRating, getTokenHeader, googleBaseSchema, googleGenConfigSchema, googleSchema, googleSettings, hasActiveFiltersConfig, hasActivePiiFields, hasActivePiiPatterns, hasPermissions, hasProcessMCPServerConfig, hasTextExtractionPath, hasToolCallErrorPrefix, hostImageIdSuffix, hostImageNamePrefix, hoverCard, imageDetailNumeric, imageDetailValue, imageExtRegex, imageGenTools, imageMimeTypes, imageTypeMapping, inferMimeType, initialModelsConfig, input, inputTokensIncludesCache, interfaceSchema, isActionTool, isAgentsEndpoint, isAnthropicDocumentType, isAnthropicTextDocumentType, isAssistantsEndpoint, isBedrockDocumentType, isCodeEnvironmentMode, isCodeWorkerShell, isCodeWorkspaceSelection, isCodeWorkspaceSelectionErrorReason, isCodeWorkspaceSelections, isCompactedLeaf, isCronCadence, isDocumentSupportedProvider, isEphemeralAgentId, isImageVisionTool, isKnownProviderIdentifier, isMediaSupportedProvider, isMessageFileUpload, isMythosClassModel, isNativelyReadableText, isOpenAILikeProvider, isParamEndpoint, isPermissiveMimeConfig, isProcessMCPServerConfig, isProcessMCPServerField, isRemoteOidcUrlAllowed, isReportableRunStepDuration, isResponsesApiUpload, isSecureCodeEnvironmentControlURL, isSensitiveEnvVar, isSpeechProviderConfigured, isSystemRoleName, isThinkingDisabled, isUUID, isUserInitiatedCompaction, isValidCronExpression, knownEndpointToProvider, label, langfuseConfigSchema, langfuseTraceConfigSchema, librechat, listAgentQueuedTurnsResponseSchema, listAgentQueuedTurnsSchema, listConfiguredSpeechProviders, loginPage, mapGroupToAzureConfig, mapModelToAzureConfig, marketplacePermissionsSchema, materializeModelSpecEndpoints, mbToBytes, mcpRefreshDefaults, mcpServersPermissionsSchema, mediaSupportedProviders, 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, outputTokensFromUsage, pagination, paramDefinitionSchema, paramEndpoints, paramSettings, parseCompactConvo, parseConvo, parseEphemeralAgentId, parseLangChainErrorCode, parseTextParts, peoplePickerPermissionsSchema, permBitsToAccessLevel, permissionEntrySchema, permissionsSchema, popover, presetSettings, principalSchema, progress, promptFilterFieldSchema, promptPermissionsSchema, promptTokensFromUsage, providerEndpointMap, radioGroup, rateLimitSchema, readScheduleMCPOutcomes, reconcileContextUsage, reconcileContextUsageFromEvent, registerPage, remoteAgentsPermissionsSchema, removeCodeExecutionCaller, removeNullishValues, replaceSpecialVars, request_default as request, requiresExplicitThinkingDisabled, resolveAgentSkillsScope, resolveAllowedStatefulCodeEnvironments, resolveCodeApprovalMode, resolveCodePermissionDecision, resolveDefaultLLMDeliveryPath, resolveDefaultUploadLLMDeliveryPath, resolveDropParamsUIKeys, resolveEndpointType, resolveModelCatalogKey, resolveModelSpecEndpoint, resolveProviderId, resolveRef, resolveSandboxFilename, resolveStatefulCodeEnvironment, resolveThinkingDisplay, resolveTraceViewerConfig, resolveUploadDestination, resolveUploadLLMDeliveryPath, resolveUseResponsesApi, resourcePermissionsResponseSchema, restrictSvgReferences, retainRecentConfigSchema, retrievalMimeTypes, retrievalMimeTypesList, roleDefaults, roleSchema, runCodePermissionsSchema, scheduleCadenceSchema, scheduleFrequencies, scheduleMCPOutcomeSchema, 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, stripToolCallErrorPrefix, 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, traceViewerDefaults, traceViewerLimits, 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