librechat-data-provider 0.8.522 → 0.8.524

package/dist/types/parameterSettings.d.ts

@@ -1,3 +1,4 @@
+import type { ResponsesApiRouting } from './types';
 import { SettingDefinition, SettingsConfiguration } from './generate';
 export declare const librechat: {
     modelLabel: {
@@ -65,6 +66,14 @@ export declare const librechat: {
     };
 };
 export declare const paramSettings: Record<string, SettingsConfiguration | undefined>;
+/**
+ * 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.
+ */
+export declare function resolveDropParamsUIKeys(dropParams: string[] | undefined, endpointKey: string): Set<string>;
 export declare const presetSettings: Record<string, {
     col1: SettingsConfiguration;
     col2: SettingsConfiguration;
@@ -76,4 +85,4 @@ export declare const agentParamSettings: Record<string, SettingsConfiguration |
  * 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;
+export declare function applyModelAwareDefaults(settings: SettingsConfiguration, endpoint: string, model?: string, responsesApiRouting?: ResponsesApiRouting): SettingsConfiguration;

package/dist/types/parsers.d.ts

@@ -1,5 +1,5 @@
 import type { ZodIssue } from 'zod';
-import type * as a from './types/assistants';
+import type * as a from './types/content';
 import type * as s from './schemas';
 import type * as t from './types';
 import { EModelEndpoint } from './schemas';
@@ -60,6 +60,30 @@ export declare function getEphemeralSender({ modelLabel, specLabel, modelDisplay
     specLabel?: string | null;
     modelDisplayLabel?: string | null;
 }): string;
+/**
+ * Whether a persisted `sender` is a label someone configured rather than the
+ * model-derived name `getResponseSender` produces.
+ *
+ * The sender is the one thing that records which it was: `resolveSender` writes an
+ * agent's name, then the `getEphemeralSender` chain (`modelLabel` → a model spec's
+ * `label` → an endpoint's `modelDisplayLabel`), and falls back to `getResponseSender`
+ * only when none of those is set. Asking the message rather than the conversation
+ * settles three things a settings lookup cannot: labels that live in config a caller
+ * may not hold, labels an endpoint ignores (Anthropic keeps reading `Claude` whatever
+ * `chatGptLabel` says, and matches here), and labels changed since the message was
+ * written — its header still shows the sender it was written under.
+ *
+ * Equality is the test, so the only way to be wrong is a stored name that no longer
+ * matches what the current heuristics produce, which withholds a model rather than
+ * revealing one.
+ */
+export declare const isConfiguredSender: ({ sender, endpoint, endpointType, model, isCreatedByUser, }: {
+    sender?: string | null;
+    endpoint?: EModelEndpoint | string | null;
+    endpointType?: EModelEndpoint | string | null;
+    model?: string | null;
+    isCreatedByUser?: boolean | null;
+}) => boolean;
 /**
  * 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/providers.d.ts

@@ -17,6 +17,7 @@ export declare enum ProviderId {
     groq = "groq",
     helicone = "helicone",
     huggingface = "huggingface",
+    lemonade = "lemonade",
     mistral = "mistral",
     mlx = "mlx",
     ollama = "ollama",

package/dist/types/resolve-llm-delivery-path.d.ts

@@ -0,0 +1,161 @@
+import type { TDefaultLLMDeliveryPath, TDefaultLLMDeliveryPathConfig } from './file-config';
+import type { EndpointFileConfig, FileConfig, RegexLike } from './types/files';
+import type { CodeEnvReferenceSet } from './codeEnvRef';
+import type { TEndpoint } from './config';
+/**
+ * The native provider a custom endpoint declares, when it declares one. A custom endpoint
+ * speaks OpenAI's API unless its config names another dialect, and the upload route needs
+ * that answer for the same reason request initialization does: the media encoders emit
+ * OpenAI-format parts, so a custom endpoint running as Anthropic receives none.
+ */
+export declare function getCustomEndpointProvider(customEndpoints: Array<Partial<Pick<TEndpoint, 'name' | 'provider'>>> | undefined, endpoint?: string | null): string | undefined;
+export declare const SYSTEM_LLM_DELIVERY_DEFAULTS: Required<TDefaultLLMDeliveryPathConfig>;
+export declare function isNativelyReadableText(mimeType: string): boolean;
+export declare function hasTextExtractionPath(mimeType: string): boolean;
+/**
+ * Resolves the default file path destination for a given mime type.
+ * Resolution chain: endpoint overrides -> endpoint fallback -> global overrides -> global fallback -> system defaults.
+ */
+export declare function resolveDefaultLLMDeliveryPath(mimeType: string, endpointConfig?: TDefaultLLMDeliveryPathConfig, globalConfig?: TDefaultLLMDeliveryPathConfig, endpoint?: string, useResponsesApi?: boolean, sttConfigured?: boolean, supportedMimeTypes?: RegexLike[]): TDefaultLLMDeliveryPath;
+/**
+ * Delivery path for an upload that named no tool resource. The legacy chooser makes the
+ * destination explicit, so nothing is inferred there.
+ */
+export declare function resolveDefaultUploadLLMDeliveryPath({ mimeType, endpointConfig, fileConfig, endpoint, endpointProvider, useResponsesApi, sttConfigured, }: {
+    mimeType: string;
+    endpointConfig?: EndpointFileConfig;
+    fileConfig?: FileConfig;
+    endpoint?: string;
+    /** The provider the endpoint runs as, when the caller knows it: a custom endpoint's
+     *  declared dialect at upload time, the agent's resolved provider at turn time. */
+    endpointProvider?: string | null;
+    useResponsesApi?: boolean;
+    sttConfigured?: boolean;
+}): TDefaultLLMDeliveryPath;
+/** Delivery path for an upload, honoring an explicitly chosen tool resource. */
+export declare function resolveUploadLLMDeliveryPath({ toolResource, mimeType, endpointConfig, fileConfig, endpoint, useResponsesApi, endpointProvider, sttConfigured, }: {
+    toolResource?: string | null;
+    mimeType: string;
+    endpointConfig?: EndpointFileConfig;
+    fileConfig?: FileConfig;
+    endpoint?: string;
+    endpointProvider?: string | null;
+    useResponsesApi?: boolean;
+    sttConfigured?: boolean;
+}): TDefaultLLMDeliveryPath;
+/**
+ * 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.
+ */
+export declare function canToolResourceConsume(toolResource: string, mimeType: string): boolean;
+/**
+ * The file-reading tools one agent's turn runs. Each flag requires deployment capability,
+ * the caller's role grant, and a reader in the final loaded tool set.
+ */
+export interface TurnFileConsumers {
+    executeCode: boolean;
+    fileSearch: boolean;
+}
+/**
+ * Whether the record shows this file reached a tool's own store: vectors for file search, a
+ * sandbox pointer for code execution. Nothing else writes either, so their presence is proof
+ * the file was provisioned and their absence proof it was not. The same evidence deferred
+ * provisioning reads before queueing a file, so a turn cannot withhold content for a tool that
+ * provisioning has yet to serve.
+ */
+export declare function hasToolResourceProvisioning(file: TurnDeliveryFile, toolResource: string): boolean;
+/**
+ * Whether a tool this turn runs can read a file of this type.
+ *
+ * Passing the record asks the stricter question a delivery decision needs where a tool serves
+ * only what it already holds. File search reads the vector store, and an upload that named no
+ * destination is filed under no tool at all, so an enabled search tool is a reader only once
+ * the record shows the store holds the file. Run Code needs no copy in advance: its first call
+ * uploads every attachment it can read to the sandbox, so enabling it is enough. Requiring a
+ * copy there would hand the file's text to the prompt on every turn before the first code run,
+ * and a turn that refuses that text never runs code, so the file would never become held.
+ */
+export declare function hasTurnFileConsumer(mimeType: string, consumers: TurnFileConsumers, file?: TurnDeliveryFile): boolean;
+/**
+ * The inputs that route every attachment for the agent running a turn. Initialization
+ * settles them once, after the provider swap and the Responses API decision, and every
+ * reader of a turn route consumes this value rather than deriving one from the agent.
+ */
+export interface TurnDeliveryRouting {
+    fileConfig: FileConfig;
+    endpointConfig: EndpointFileConfig;
+    /** The endpoint the file policy is configured under: a custom endpoint's own name, not
+     *  the client family initialization runs it as. */
+    endpoint: string;
+    /** The dialect a custom endpoint declares, which decides whether it receives OpenAI-format
+     *  media; undefined for a built-in or OpenAI-compatible endpoint. */
+    endpointProvider?: string;
+    useResponsesApi?: boolean;
+    sttConfigured: boolean;
+}
+/** The fields of an attachment record that decide its delivery on a turn. */
+export interface TurnDeliveryFile {
+    type?: string;
+    text?: string | null;
+    /** Stored as an upload-time inference, so any string may be read back. */
+    llmDeliveryPath?: string | null;
+    /** Whether a vector store holds this file, which is what lets file search serve it.
+     *  Records predating namespace tracking carry only this flag. */
+    embedded?: boolean | null;
+    metadata?: ({
+        routingMimeType?: string;
+        destinationChosen?: boolean;
+        /** Vector namespaces holding this file, written as each embedding succeeds. */
+        embeddedEntities?: string[];
+    } & CodeEnvReferenceSet) | null;
+}
+/** Whether a record's stored route was inferred at upload, so each turn resolves it again. */
+export declare function hasInferredLLMDeliveryPath(file: TurnDeliveryFile): boolean;
+/**
+ * Delivery path for one attachment on one agent's turn.
+ *
+ * A record predating routing and a destination the user chose keep what they stored. An
+ * inferred route re-resolves against the endpoint handling the turn. A `none` route leaves
+ * the file for a tool; where the endpoint enables `textFallbackWithoutTools` and no tool this
+ * turn runs can read the file, the text extracted at upload is delivered rather than the file
+ * reaching nothing. Consumers left undefined are unknown and not judged, as in
+ * {@link resolveUploadDestination}.
+ *
+ * For file search, reading is asked of the record rather than of the tool set, because the two
+ * disagree for the upload that needs the fallback most: one that named no destination is filed
+ * under no tool, so enabling file search would otherwise withhold the text for a vector store
+ * that never received the file. Run Code is judged by the tool set: see
+ * {@link hasTurnFileConsumer}.
+ */
+export declare function resolveTurnLLMDeliveryPath(routing: Partial<TurnDeliveryRouting> | undefined, file: TurnDeliveryFile, consumers?: TurnFileConsumers): TDefaultLLMDeliveryPath | undefined;
+/** Why an upload cannot be accepted, when nothing would be able to read it. */
+export type UploadRejection = 'no-agent-resource' | 'context-disabled' | 'no-consumer';
+/**
+ * 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.
+ */
+export declare function resolveUploadDestination(params: {
+    toolResource?: string | null;
+    deliveryPath: TDefaultLLMDeliveryPath;
+    mimeType: string;
+    agentTools?: string[];
+    hasAgent: boolean;
+    isMessageAttachment: boolean;
+    /** True when a message attachment may acquire a compatible tool on a later turn. */
+    allowUnknownMessageConsumer?: boolean;
+    /** Undefined when not looked up, as for an upload that cannot land on context. */
+    contextEnabled?: boolean;
+}): {
+    toolResource?: string;
+    rejection?: UploadRejection;
+};