librechat-data-provider 0.8.521 → 0.8.522

package/dist/types/parameterSettings.d.ts

@@ -1,4 +1,4 @@
-import { SettingsConfiguration } from './generate';
+import { SettingDefinition, SettingsConfiguration } from './generate';
 export declare const librechat: {
     modelLabel: {
         readonly key: "modelLabel";
@@ -48,6 +48,9 @@ export declare const librechat: {
         readonly placeholderCode: true;
         readonly 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: SettingDefinition;
     fileTokenLimit: {
         readonly key: "fileTokenLimit";
         readonly label: "com_ui_file_token_limit";
@@ -71,5 +74,6 @@ export declare const agentParamSettings: Record<string, SettingsConfiguration |
  * 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.
  */
 export declare function applyModelAwareDefaults(settings: SettingsConfiguration, endpoint: string, model?: string): SettingsConfiguration;

package/dist/types/parsers.d.ts

@@ -50,6 +50,16 @@ export type ParsedEphemeralAgentId = {
     sender?: string;
     index?: number;
 };
+/**
+ * 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).
+ */
+export declare function getEphemeralSender({ modelLabel, specLabel, modelDisplayLabel, }: {
+    modelLabel?: string | null;
+    specLabel?: string | null;
+    modelDisplayLabel?: string | null;
+}): string;
 /**
  * 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.

package/dist/types/permissions.d.ts

@@ -66,7 +66,11 @@ export declare enum PermissionTypes {
     /**
      * Type for Shared Link Permissions
      */
-    SHARED_LINKS = "SHARED_LINKS"
+    SHARED_LINKS = "SHARED_LINKS",
+    /**
+     * Type for Scheduled Chats Permissions
+     */
+    SCHEDULES = "SCHEDULES"
 }
 /**
  * Maps PermissionTypes to their corresponding `interface` config field names.
@@ -76,6 +80,14 @@ export declare enum PermissionTypes {
 export declare const PERMISSION_TYPE_INTERFACE_FIELDS: Record<PermissionTypes, string>;
 /** Set of interface config field names that correspond to role permissions. */
 export declare const INTERFACE_PERMISSION_FIELDS: Set<string>;
+/**
+ * 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.
+ */
+export declare const RUNTIME_CONFIG_INTERFACE_FIELDS: Set<string>;
 /**
  * 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
@@ -302,6 +314,17 @@ export declare const skillPermissionsSchema: z.ZodObject<{
     SHARE_PUBLIC?: boolean | undefined;
 }>;
 export type TSkillPermissions = z.infer<typeof skillPermissionsSchema>;
+export declare const schedulesPermissionsSchema: z.ZodObject<{
+    USE: z.ZodDefault<z.ZodBoolean>;
+    CREATE: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    USE: boolean;
+    CREATE: boolean;
+}, {
+    USE?: boolean | undefined;
+    CREATE?: boolean | undefined;
+}>;
+export type TSchedulesPermissions = z.infer<typeof schedulesPermissionsSchema>;
 export declare const sharedLinksPermissionsSchema: z.ZodObject<{
     CREATE: z.ZodDefault<z.ZodBoolean>;
     SHARE: z.ZodDefault<z.ZodBoolean>;
@@ -501,6 +524,16 @@ export declare const permissionsSchema: z.ZodObject<{
         SHARE?: boolean | undefined;
         SHARE_PUBLIC?: boolean | undefined;
     }>;
+    SCHEDULES: z.ZodObject<{
+        USE: z.ZodDefault<z.ZodBoolean>;
+        CREATE: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        USE: boolean;
+        CREATE: boolean;
+    }, {
+        USE?: boolean | undefined;
+        CREATE?: boolean | undefined;
+    }>;
 }, "strip", z.ZodTypeAny, {
     PROMPTS: {
         USE: boolean;
@@ -574,6 +607,10 @@ export declare const permissionsSchema: z.ZodObject<{
         SHARE: boolean;
         SHARE_PUBLIC: boolean;
     };
+    SCHEDULES: {
+        USE: boolean;
+        CREATE: boolean;
+    };
 }, {
     PROMPTS: {
         USE?: boolean | undefined;
@@ -647,4 +684,8 @@ export declare const permissionsSchema: z.ZodObject<{
         SHARE?: boolean | undefined;
         SHARE_PUBLIC?: boolean | undefined;
     };
+    SCHEDULES: {
+        USE?: boolean | undefined;
+        CREATE?: boolean | undefined;
+    };
 }>;

package/dist/types/providers.d.ts

@@ -0,0 +1,36 @@
+import { EModelEndpoint } from './schemas';
+import { KnownEndpoints } from './config';
+/** Canonical provider identity used for branding across client and server. */
+export declare enum ProviderId {
+    openai = "openai",
+    anthropic = "anthropic",
+    google = "google",
+    azure = "azure",
+    bedrock = "bedrock",
+    xai = "xai",
+    moonshot = "moonshot",
+    anyscale = "anyscale",
+    apipie = "apipie",
+    cohere = "cohere",
+    deepseek = "deepseek",
+    fireworks = "fireworks",
+    groq = "groq",
+    helicone = "helicone",
+    huggingface = "huggingface",
+    mistral = "mistral",
+    mlx = "mlx",
+    ollama = "ollama",
+    openrouter = "openrouter",
+    perplexity = "perplexity",
+    qwen = "qwen",
+    shuttleai = "shuttleai",
+    together = "together",
+    unify = "unify",
+    vercel = "vercel"
+}
+export declare const endpointToProvider: Partial<Record<EModelEndpoint, ProviderId>>;
+export declare const knownEndpointToProvider: Record<KnownEndpoints, ProviderId>;
+/** Resolves free-form provider text to a canonical id, ignoring case and separators. */
+export declare function resolveProviderId(input?: string | null): ProviderId | null;
+/** Resolves a runtime provider to its model catalog, using a native alias only when needed. */
+export declare function resolveModelCatalogKey<T>(provider?: string | null, catalogs?: Partial<Record<string, T>>): string;

package/dist/types/request.d.ts

@@ -1,7 +1,7 @@
-import type { AxiosRequestConfig } from 'axios';
+import type { AxiosRequestConfig, AxiosResponse } from 'axios';
 import type * as t from './types';
 declare function _get<T>(url: string, options?: AxiosRequestConfig): Promise<T>;
-declare function _getResponse<T>(url: string, options?: AxiosRequestConfig): Promise<T>;
+declare function _getResponse<T = unknown>(url: string, options?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
 declare function _post(url: string, data?: any): Promise<any>;
 declare function _postMultiPart(url: string, formData: FormData, options?: AxiosRequestConfig): Promise<any>;
 declare function _postTTS(url: string, formData: FormData, options?: AxiosRequestConfig): Promise<any>;

package/dist/types/roles.d.ts

@@ -199,6 +199,16 @@ export declare const roleSchema: z.ZodObject<{
             SHARE?: boolean | undefined;
             SHARE_PUBLIC?: boolean | undefined;
         }>;
+        SCHEDULES: z.ZodObject<{
+            USE: z.ZodDefault<z.ZodBoolean>;
+            CREATE: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            USE: boolean;
+            CREATE: boolean;
+        }, {
+            USE?: boolean | undefined;
+            CREATE?: boolean | undefined;
+        }>;
     }, "strip", z.ZodTypeAny, {
         PROMPTS: {
             USE: boolean;
@@ -272,6 +282,10 @@ export declare const roleSchema: z.ZodObject<{
             SHARE: boolean;
             SHARE_PUBLIC: boolean;
         };
+        SCHEDULES: {
+            USE: boolean;
+            CREATE: boolean;
+        };
     }, {
         PROMPTS: {
             USE?: boolean | undefined;
@@ -345,6 +359,10 @@ export declare const roleSchema: z.ZodObject<{
             SHARE?: boolean | undefined;
             SHARE_PUBLIC?: boolean | undefined;
         };
+        SCHEDULES: {
+            USE?: boolean | undefined;
+            CREATE?: boolean | undefined;
+        };
     }>;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -421,6 +439,10 @@ export declare const roleSchema: z.ZodObject<{
             SHARE: boolean;
             SHARE_PUBLIC: boolean;
         };
+        SCHEDULES: {
+            USE: boolean;
+            CREATE: boolean;
+        };
     };
 }, {
     name: string;
@@ -497,6 +519,10 @@ export declare const roleSchema: z.ZodObject<{
             SHARE?: boolean | undefined;
             SHARE_PUBLIC?: boolean | undefined;
         };
+        SCHEDULES: {
+            USE?: boolean | undefined;
+            CREATE?: boolean | undefined;
+        };
     };
 }>;
 export type TRole = z.infer<typeof roleSchema>;
@@ -578,6 +604,10 @@ export declare const roleDefaults: {
                 SHARE: boolean;
                 SHARE_PUBLIC: boolean;
             };
+            SCHEDULES: {
+                USE: boolean;
+                CREATE: boolean;
+            };
         };
     };
     USER: {
@@ -655,6 +685,10 @@ export declare const roleDefaults: {
                 SHARE: boolean;
                 SHARE_PUBLIC: boolean;
             };
+            SCHEDULES: {
+                USE: boolean;
+                CREATE: boolean;
+            };
         };
     };
 };

package/dist/types/runSteps.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The timestamp pair these helpers derive from.
+ *
+ * Both stamps are optional here even though `closed_at` is required on
+ * `Agents.RunStepClosedEvent`, because not every caller holds a well-typed
+ * event: the Redis replay branch reconstructs closures from persisted JSON and
+ * legitimately has nothing stronger than "might be a number". Widening the
+ * parameter rather than making callers assert keeps the guards below as the
+ * single place that decides what is trustworthy — an assertion at a call site
+ * would move that decision somewhere it cannot be enforced.
+ */
+export interface RunStepTimestamps {
+    created_at?: number;
+    closed_at?: number;
+}
+/**
+ * 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.
+ */
+export declare const MIN_REPORTABLE_RUN_STEP_DURATION_MS = 1000;
+/**
+ * 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.
+ */
+export declare function getRunStepDurationMs(closed: RunStepTimestamps): number | undefined;
+/**
+ * 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.
+ */
+export declare function isReportableRunStepDuration(durationMs?: number): durationMs is number;