librechat-data-provider 0.7.86 → 0.7.87

package/src/permissions.ts

@@ -16,6 +16,10 @@ export enum PermissionTypes {
    * Type for Agent Permissions
    */
   AGENTS = 'AGENTS',
+  /**
+   * Type for Memory Permissions
+   */
+  MEMORIES = 'MEMORIES',
   /**
    * Type for Multi-Conversation Permissions
    */
@@ -45,6 +49,8 @@ export enum Permissions {
   READ = 'READ',
   READ_AUTHOR = 'READ_AUTHOR',
   SHARE = 'SHARE',
+  /** Can disable if desired */
+  OPT_OUT = 'OPT_OUT',
 }
 
 export const promptPermissionsSchema = z.object({
@@ -60,6 +66,15 @@ export const bookmarkPermissionsSchema = z.object({
 });
 export type TBookmarkPermissions = z.infer<typeof bookmarkPermissionsSchema>;
 
+export const memoryPermissionsSchema = z.object({
+  [Permissions.USE]: z.boolean().default(true),
+  [Permissions.CREATE]: z.boolean().default(true),
+  [Permissions.UPDATE]: z.boolean().default(true),
+  [Permissions.READ]: z.boolean().default(true),
+  [Permissions.OPT_OUT]: z.boolean().default(true),
+});
+export type TMemoryPermissions = z.infer<typeof memoryPermissionsSchema>;
+
 export const agentPermissionsSchema = z.object({
   [Permissions.SHARED_GLOBAL]: z.boolean().default(false),
   [Permissions.USE]: z.boolean().default(true),
@@ -92,6 +107,7 @@ export type TWebSearchPermissions = z.infer<typeof webSearchPermissionsSchema>;
 export const permissionsSchema = z.object({
   [PermissionTypes.PROMPTS]: promptPermissionsSchema,
   [PermissionTypes.BOOKMARKS]: bookmarkPermissionsSchema,
+  [PermissionTypes.MEMORIES]: memoryPermissionsSchema,
   [PermissionTypes.AGENTS]: agentPermissionsSchema,
   [PermissionTypes.MULTI_CONVO]: multiConvoPermissionsSchema,
   [PermissionTypes.TEMPORARY_CHAT]: temporaryChatPermissionsSchema,

package/src/react-query/react-query-service.ts

@@ -347,3 +347,19 @@ export const useGetCustomConfigSpeechQuery = (
     },
   );
 };
+
+export const useUpdateFeedbackMutation = (
+  conversationId: string,
+  messageId: string,
+): UseMutationResult<t.TUpdateFeedbackResponse, Error, t.TUpdateFeedbackRequest> => {
+  const queryClient = useQueryClient();
+  return useMutation(
+    (payload: t.TUpdateFeedbackRequest) =>
+      dataService.updateFeedback(conversationId, messageId, payload),
+    {
+      onSuccess: () => {
+        queryClient.invalidateQueries([QueryKeys.messages, messageId]);
+      },
+    },
+  );
+};

package/src/roles.ts

@@ -5,6 +5,7 @@ import {
   permissionsSchema,
   agentPermissionsSchema,
   promptPermissionsSchema,
+  memoryPermissionsSchema,
   runCodePermissionsSchema,
   webSearchPermissionsSchema,
   bookmarkPermissionsSchema,
@@ -48,6 +49,13 @@ const defaultRolesSchema = z.object({
       [PermissionTypes.BOOKMARKS]: bookmarkPermissionsSchema.extend({
         [Permissions.USE]: z.boolean().default(true),
       }),
+      [PermissionTypes.MEMORIES]: memoryPermissionsSchema.extend({
+        [Permissions.USE]: z.boolean().default(true),
+        [Permissions.CREATE]: z.boolean().default(true),
+        [Permissions.UPDATE]: z.boolean().default(true),
+        [Permissions.READ]: z.boolean().default(true),
+        [Permissions.OPT_OUT]: z.boolean().default(true),
+      }),
       [PermissionTypes.AGENTS]: agentPermissionsSchema.extend({
         [Permissions.SHARED_GLOBAL]: z.boolean().default(true),
         [Permissions.USE]: z.boolean().default(true),
@@ -86,6 +94,13 @@ export const roleDefaults = defaultRolesSchema.parse({
       [PermissionTypes.BOOKMARKS]: {
         [Permissions.USE]: true,
       },
+      [PermissionTypes.MEMORIES]: {
+        [Permissions.USE]: true,
+        [Permissions.CREATE]: true,
+        [Permissions.UPDATE]: true,
+        [Permissions.READ]: true,
+        [Permissions.OPT_OUT]: true,
+      },
       [PermissionTypes.AGENTS]: {
         [Permissions.SHARED_GLOBAL]: true,
         [Permissions.USE]: true,
@@ -110,6 +125,7 @@ export const roleDefaults = defaultRolesSchema.parse({
     permissions: {
       [PermissionTypes.PROMPTS]: {},
       [PermissionTypes.BOOKMARKS]: {},
+      [PermissionTypes.MEMORIES]: {},
       [PermissionTypes.AGENTS]: {},
       [PermissionTypes.MULTI_CONVO]: {},
       [PermissionTypes.TEMPORARY_CHAT]: {},

package/src/schemas.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Tools } from './types/assistants';
 import type { TMessageContentParts, FunctionTool, FunctionToolCall } from './types/assistants';
+import { TFeedback, feedbackSchema } from './feedback';
 import type { SearchResultData } from './types/web';
 import type { TEphemeralAgent } from './types';
 import type { TFile } from './types/files';
@@ -518,13 +519,22 @@ export const tMessageSchema = z.object({
   thread_id: z.string().optional(),
   /* frontend components */
   iconURL: z.string().nullable().optional(),
+  feedback: feedbackSchema.optional(),
 });
 
+export type MemoryArtifact = {
+  key: string;
+  value?: string;
+  tokenCount?: number;
+  type: 'update' | 'delete';
+};
+
 export type TAttachmentMetadata = {
   type?: Tools;
   messageId: string;
   toolCallId: string;
   [Tools.web_search]?: SearchResultData;
+  [Tools.memory]?: MemoryArtifact;
 };
 
 export type TAttachment =
@@ -543,6 +553,7 @@ export type TMessage = z.input<typeof tMessageSchema> & {
   siblingIndex?: number;
   attachments?: TAttachment[];
   clientTimestamp?: string;
+  feedback?: TFeedback;
 };
 
 export const coerceNumber = z.union([z.number(), z.string()]).transform((val) => {

package/src/types/assistants.ts

@@ -22,6 +22,7 @@ export enum Tools {
   web_search = 'web_search',
   retrieval = 'retrieval',
   function = 'function',
+  memory = 'memory',
 }
 
 export enum EToolResources {

package/src/types/mutations.ts

@@ -278,7 +278,7 @@ export type UpdatePermVars<T> = {
 };
 
 export type UpdatePromptPermVars = UpdatePermVars<p.TPromptPermissions>;
-
+export type UpdateMemoryPermVars = UpdatePermVars<p.TMemoryPermissions>;
 export type UpdateAgentPermVars = UpdatePermVars<p.TAgentPermissions>;
 
 export type UpdatePermResponse = r.TRole;
@@ -290,6 +290,13 @@ export type UpdatePromptPermOptions = MutationOptions<
   types.TError | null | undefined
 >;
 
+export type UpdateMemoryPermOptions = MutationOptions<
+  UpdatePermResponse,
+  UpdateMemoryPermVars,
+  unknown,
+  types.TError | null | undefined
+>;
+
 export type UpdateAgentPermOptions = MutationOptions<
   UpdatePermResponse,
   UpdateAgentPermVars,

package/src/types/queries.ts

@@ -109,3 +109,18 @@ export type VerifyToolAuthResponse = {
 
 export type GetToolCallParams = { conversationId: string };
 export type ToolCallResults = a.ToolCallResult[];
+
+/* Memories */
+export type TUserMemory = {
+  key: string;
+  value: string;
+  updated_at: string;
+  tokenCount?: number;
+};
+
+export type MemoriesResponse = {
+  memories: TUserMemory[];
+  totalTokens: number;
+  tokenLimit: number | null;
+  usagePercentage: number | null;
+};

package/src/types.ts

@@ -1,16 +1,19 @@
 import type OpenAI from 'openai';
 import type { InfiniteData } from '@tanstack/react-query';
 import type {
+  TBanner,
   TMessage,
   TResPlugin,
-  ImageDetail,
   TSharedLink,
   TConversation,
   EModelEndpoint,
   TConversationTag,
-  TBanner,
+  TAttachment,
 } from './schemas';
-import { SettingDefinition } from './generate';
+import type { SettingDefinition } from './generate';
+import type { TMinimalFeedback } from './feedback';
+import type { Agent } from './types/assistants';
+
 export type TOpenAIMessage = OpenAI.Chat.ChatCompletionMessageParam;
 
 export * from './schemas';
@@ -18,28 +21,78 @@ export * from './schemas';
 export type TMessages = TMessage[];
 
 /* TODO: Cleanup EndpointOption types */
-export type TEndpointOption = {
-  spec?: string | null;
-  iconURL?: string | null;
-  endpoint: EModelEndpoint;
-  endpointType?: EModelEndpoint;
+export type TEndpointOption = Pick<
+  TConversation,
+  // Core conversation fields
+  | 'endpoint'
+  | 'endpointType'
+  | 'model'
+  | 'modelLabel'
+  | 'chatGptLabel'
+  | 'promptPrefix'
+  | 'temperature'
+  | 'topP'
+  | 'topK'
+  | 'top_p'
+  | 'frequency_penalty'
+  | 'presence_penalty'
+  | 'maxOutputTokens'
+  | 'maxContextTokens'
+  | 'max_tokens'
+  | 'maxTokens'
+  | 'resendFiles'
+  | 'imageDetail'
+  | 'reasoning_effort'
+  | 'instructions'
+  | 'additional_instructions'
+  | 'append_current_datetime'
+  | 'tools'
+  | 'stop'
+  | 'region'
+  | 'additionalModelRequestFields'
+  // Anthropic-specific
+  | 'promptCache'
+  | 'thinking'
+  | 'thinkingBudget'
+  // Assistant/Agent fields
+  | 'assistant_id'
+  | 'agent_id'
+  // UI/Display fields
+  | 'iconURL'
+  | 'greeting'
+  | 'spec'
+  // Artifacts
+  | 'artifacts'
+  // Files
+  | 'file_ids'
+  // System field
+  | 'system'
+  // Google examples
+  | 'examples'
+  // Context
+  | 'context'
+> & {
+  // Fields specific to endpoint options that don't exist on TConversation
   modelDisplayLabel?: string;
-  resendFiles?: boolean;
-  promptCache?: boolean;
-  maxContextTokens?: number;
-  imageDetail?: ImageDetail;
-  model?: string | null;
-  promptPrefix?: string;
-  temperature?: number;
-  chatGptLabel?: string | null;
-  modelLabel?: string | null;
-  jailbreak?: boolean;
   key?: string | null;
-  /* assistant */
+  /** @deprecated Assistants API */
   thread_id?: string;
-  /* multi-response stream */
+  // Conversation identifiers for multi-response streams
   overrideConvoId?: string;
   overrideUserMessageId?: string;
+  // Model parameters (used by different endpoints)
+  modelOptions?: Record<string, unknown>;
+  model_parameters?: Record<string, unknown>;
+  // Configuration data (added by middleware)
+  modelsConfig?: TModelsConfig;
+  // File attachments (processed by middleware)
+  attachments?: TAttachment[];
+  // Generated prompts
+  artifactsPrompt?: string;
+  // Agent-specific fields
+  agent?: Promise<Agent>;
+  // Client-specific options
+  clientOptions?: Record<string, unknown>;
 };
 
 export type TEphemeralAgent = {
@@ -128,6 +181,9 @@ export type TUser = {
   plugins?: string[];
   twoFactorEnabled?: boolean;
   backupCodes?: TBackupCode[];
+  personalization?: {
+    memories?: boolean;
+  };
   createdAt: string;
   updatedAt: string;
 };
@@ -546,3 +602,23 @@ export type TAcceptTermsResponse = {
 };
 
 export type TBannerResponse = TBanner | null;
+
+export type TUpdateFeedbackRequest = {
+  feedback?: TMinimalFeedback;
+};
+
+export type TUpdateFeedbackResponse = {
+  messageId: string;
+  conversationId: string;
+  feedback?: TMinimalFeedback;
+};
+
+export type TBalanceResponse = {
+  tokenCredits: number;
+  // Automatic refill settings
+  autoRefillEnabled: boolean;
+  refillIntervalValue?: number;
+  refillIntervalUnit?: 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months';
+  lastRefill?: Date;
+  refillAmount?: number;
+};

package/src/web.ts

@@ -5,8 +5,8 @@ import type {
   SearchProviders,
   TWebSearchConfig,
 } from './config';
-import { extractVariableName } from './utils';
 import { SearchCategories, SafeSearchTypes } from './config';
+import { extractVariableName } from './utils';
 import { AuthType } from './schemas';
 
 export function loadWebSearchConfig(
@@ -64,23 +64,29 @@ export const webSearchAuth = {
 /**
  * Extracts all API keys from the webSearchAuth configuration object
  */
-export const webSearchKeys: TWebSearchKeys[] = [];
+export function getWebSearchKeys(): TWebSearchKeys[] {
+  const keys: TWebSearchKeys[] = [];
 
-// Iterate through each category (providers, scrapers, rerankers)
-for (const category of Object.keys(webSearchAuth)) {
-  const categoryObj = webSearchAuth[category as TWebSearchCategories];
+  // Iterate through each category (providers, scrapers, rerankers)
+  for (const category of Object.keys(webSearchAuth)) {
+    const categoryObj = webSearchAuth[category as TWebSearchCategories];
 
-  // Iterate through each service within the category
-  for (const service of Object.keys(categoryObj)) {
-    const serviceObj = categoryObj[service as keyof typeof categoryObj];
+    // Iterate through each service within the category
+    for (const service of Object.keys(categoryObj)) {
+      const serviceObj = categoryObj[service as keyof typeof categoryObj];
 
-    // Extract the API keys from the service
-    for (const key of Object.keys(serviceObj)) {
-      webSearchKeys.push(key as TWebSearchKeys);
+      // Extract the API keys from the service
+      for (const key of Object.keys(serviceObj)) {
+        keys.push(key as TWebSearchKeys);
+      }
     }
   }
+
+  return keys;
 }
 
+export const webSearchKeys: TWebSearchKeys[] = getWebSearchKeys();
+
 export function extractWebSearchEnvVars({
   keys,
   config,

package/src/zod.spec.ts

@@ -264,19 +264,19 @@ describe('convertJsonSchemaToZod', () => {
         properties: {
           name: {
             type: 'string',
-            description: 'The user\'s name',
+            description: "The user's name",
           },
           age: {
             type: 'number',
-            description: 'The user\'s age',
+            description: "The user's age",
           },
         },
       };
       const zodSchema = convertJsonSchemaToZod(schema);
 
       const shape = (zodSchema as z.ZodObject<any>).shape;
-      expect(shape.name.description).toBe('The user\'s name');
-      expect(shape.age.description).toBe('The user\'s age');
+      expect(shape.name.description).toBe("The user's name");
+      expect(shape.age.description).toBe("The user's age");
     });
 
     it('should preserve descriptions in nested objects', () => {
@@ -290,7 +290,7 @@ describe('convertJsonSchemaToZod', () => {
             properties: {
               name: {
                 type: 'string',
-                description: 'The user\'s name',
+                description: "The user's name",
               },
               settings: {
                 type: 'object',
@@ -318,7 +318,7 @@ describe('convertJsonSchemaToZod', () => {
 
         const userShape = shape.user instanceof z.ZodObject ? shape.user.shape : {};
         if ('name' in userShape && 'settings' in userShape) {
-          expect(userShape.name.description).toBe('The user\'s name');
+          expect(userShape.name.description).toBe("The user's name");
           expect(userShape.settings.description).toBe('User preferences');
 
           const settingsShape =
@@ -682,10 +682,7 @@ describe('convertJsonSchemaToZod', () => {
           name: { type: 'string' },
           age: { type: 'number' },
         },
-        anyOf: [
-          { required: ['name'] },
-          { required: ['age'] },
-        ],
+        anyOf: [{ required: ['name'] }, { required: ['age'] }],
         oneOf: [
           { properties: { role: { type: 'string', enum: ['admin'] } } },
           { properties: { role: { type: 'string', enum: ['user'] } } },
@@ -708,7 +705,7 @@ describe('convertJsonSchemaToZod', () => {
     it('should drop fields from nested schemas', () => {
       // Create a schema with nested fields that should be dropped
       const schema: JsonSchemaType & {
-        properties?: Record<string, JsonSchemaType & { anyOf?: any; oneOf?: any }>
+        properties?: Record<string, JsonSchemaType & { anyOf?: any; oneOf?: any }>;
       } = {
         type: 'object',
         properties: {
@@ -718,10 +715,7 @@ describe('convertJsonSchemaToZod', () => {
               name: { type: 'string' },
               role: { type: 'string' },
             },
-            anyOf: [
-              { required: ['name'] },
-              { required: ['role'] },
-            ],
+            anyOf: [{ required: ['name'] }, { required: ['role'] }],
           },
           settings: {
             type: 'object',
@@ -742,20 +736,24 @@ describe('convertJsonSchemaToZod', () => {
       });
 
       // The schema should still validate normal properties
-      expect(zodSchema?.parse({
-        user: { name: 'John', role: 'admin' },
-        settings: { theme: 'custom' }, // This would fail if oneOf was still present
-      })).toEqual({
+      expect(
+        zodSchema?.parse({
+          user: { name: 'John', role: 'admin' },
+          settings: { theme: 'custom' }, // This would fail if oneOf was still present
+        }),
+      ).toEqual({
         user: { name: 'John', role: 'admin' },
         settings: { theme: 'custom' },
       });
 
       // But the anyOf constraint should be gone from user
       // (If it was present, this would fail because neither name nor role is required)
-      expect(zodSchema?.parse({
-        user: {},
-        settings: { theme: 'light' },
-      })).toEqual({
+      expect(
+        zodSchema?.parse({
+          user: {},
+          settings: { theme: 'light' },
+        }),
+      ).toEqual({
         user: {},
         settings: { theme: 'light' },
       });
@@ -803,10 +801,7 @@ describe('convertJsonSchemaToZod', () => {
                       anyOf: [{ minItems: 1 }],
                     },
                   },
-                  oneOf: [
-                    { required: ['name', 'permissions'] },
-                    { required: ['name'] },
-                  ],
+                  oneOf: [{ required: ['name', 'permissions'] }, { required: ['name'] }],
                 },
               },
             },
@@ -871,10 +866,7 @@ describe('convertJsonSchemaToZod', () => {
       const schema = {
         type: 'object', // Add a type to satisfy JsonSchemaType
         properties: {}, // Empty properties
-        oneOf: [
-          { type: 'string' },
-          { type: 'number' },
-        ],
+        oneOf: [{ type: 'string' }, { type: 'number' }],
       } as JsonSchemaType & { oneOf?: any };
 
       // Convert with transformOneOfAnyOf option
@@ -893,10 +885,7 @@ describe('convertJsonSchemaToZod', () => {
       const schema = {
         type: 'object', // Add a type to satisfy JsonSchemaType
         properties: {}, // Empty properties
-        anyOf: [
-          { type: 'string' },
-          { type: 'number' },
-        ],
+        anyOf: [{ type: 'string' }, { type: 'number' }],
       } as JsonSchemaType & { anyOf?: any };
 
       // Convert with transformOneOfAnyOf option
@@ -956,10 +945,7 @@ describe('convertJsonSchemaToZod', () => {
         properties: {
           value: { type: 'string' },
         },
-        oneOf: [
-          { required: ['value'] },
-          { properties: { optional: { type: 'boolean' } } },
-        ],
+        oneOf: [{ required: ['value'] }, { properties: { optional: { type: 'boolean' } } }],
       } as JsonSchemaType & { oneOf?: any };
 
       // Convert with transformOneOfAnyOf option
@@ -1013,9 +999,12 @@ describe('convertJsonSchemaToZod', () => {
           },
         },
       } as JsonSchemaType & {
-        properties?: Record<string, JsonSchemaType & {
-          properties?: Record<string, JsonSchemaType & { oneOf?: any }>
-        }>
+        properties?: Record<
+          string,
+          JsonSchemaType & {
+            properties?: Record<string, JsonSchemaType & { oneOf?: any }>;
+          }
+        >;
       };
 
       // Convert with transformOneOfAnyOf option
@@ -1024,14 +1013,16 @@ describe('convertJsonSchemaToZod', () => {
       });
 
       // The schema should validate nested unions
-      expect(zodSchema?.parse({
-        user: {
-          contact: {
-            type: 'email',
-            email: 'test@example.com',
+      expect(
+        zodSchema?.parse({
+          user: {
+            contact: {
+              type: 'email',
+              email: 'test@example.com',
+            },
           },
-        },
-      })).toEqual({
+        }),
+      ).toEqual({
         user: {
           contact: {
             type: 'email',
@@ -1040,14 +1031,16 @@ describe('convertJsonSchemaToZod', () => {
         },
       });
 
-      expect(zodSchema?.parse({
-        user: {
-          contact: {
-            type: 'phone',
-            phone: '123-456-7890',
+      expect(
+        zodSchema?.parse({
+          user: {
+            contact: {
+              type: 'phone',
+              phone: '123-456-7890',
+            },
           },
-        },
-      })).toEqual({
+        }),
+      ).toEqual({
         user: {
           contact: {
             type: 'phone',
@@ -1057,14 +1050,16 @@ describe('convertJsonSchemaToZod', () => {
       });
 
       // Should reject invalid contact types
-      expect(() => zodSchema?.parse({
-        user: {
-          contact: {
-            type: 'email',
-            phone: '123-456-7890', // Missing email, has phone instead
+      expect(() =>
+        zodSchema?.parse({
+          user: {
+            contact: {
+              type: 'email',
+              phone: '123-456-7890', // Missing email, has phone instead
+            },
           },
-        },
-      })).toThrow();
+        }),
+      ).toThrow();
     });
 
     it('should work with dropFields option', () => {
@@ -1072,10 +1067,7 @@ describe('convertJsonSchemaToZod', () => {
       const schema = {
         type: 'object', // Add a type to satisfy JsonSchemaType
         properties: {}, // Empty properties
-        oneOf: [
-          { type: 'string' },
-          { type: 'number' },
-        ],
+        oneOf: [{ type: 'string' }, { type: 'number' }],
         deprecated: true, // Field to drop
       } as JsonSchemaType & { oneOf?: any; deprecated?: boolean };