librechat-data-provider 0.7.430 → 0.7.692

package/src/types.ts

@@ -1,4 +1,4 @@
-import OpenAI from 'openai';
+import type OpenAI from 'openai';
 import type { InfiniteData } from '@tanstack/react-query';
 import type {
   TMessage,
@@ -10,10 +10,7 @@ import type {
   TConversationTag,
   TBanner,
 } from './schemas';
-import type { TSpecsConfig } from './models';
 export type TOpenAIMessage = OpenAI.Chat.ChatCompletionMessageParam;
-export type TOpenAIFunction = OpenAI.Chat.ChatCompletionCreateParams.Function;
-export type TOpenAIFunctionCall = OpenAI.Chat.ChatCompletionCreateParams.FunctionCallOption;
 
 export * from './schemas';
 
@@ -64,6 +61,7 @@ export type TSubmission = {
   initialResponse?: TMessage;
   conversation: Partial<TConversation>;
   endpointOption: TEndpointOption;
+  clientTimestamp?: string;
 };
 
 export type EventSubmission = Omit<TSubmission, 'initialResponse'> & { initialResponse: TMessage };
@@ -72,14 +70,13 @@ export type TPluginAction = {
   pluginKey: string;
   action: 'install' | 'uninstall';
   auth?: unknown;
-  isAssistantTool?: boolean;
+  isEntityTool?: boolean;
 };
 
 export type GroupedConversations = [key: string, TConversation[]][];
 
 export type TUpdateUserPlugins = {
-  isAssistantTool?: boolean;
-  isAgentTool?: boolean;
+  isEntityTool?: boolean;
   pluginKey: string;
   action: string;
   auth?: unknown;
@@ -110,7 +107,7 @@ export type TUser = {
   avatar: string;
   role: string;
   provider: string;
-  plugins: string[];
+  plugins?: string[];
   createdAt: string;
   updatedAt: string;
 };
@@ -152,6 +149,7 @@ export type TUpdateConversationResponse = TConversation;
 export type TDeleteConversationRequest = {
   conversationId?: string;
   thread_id?: string;
+  endpoint?: string;
   source?: string;
 };
 
@@ -196,12 +194,24 @@ export type TConversationTagRequest = Partial<
 
 export type TConversationTagResponse = TConversationTag;
 
-// type for tagging conversation
 export type TTagConversationRequest = {
   tags: string[];
+  tag: string;
 };
+
 export type TTagConversationResponse = string[];
 
+export type TDuplicateConvoRequest = {
+  conversationId?: string;
+};
+
+export type TDuplicateConvoResponse =
+  | {
+      conversation: TConversation;
+      messages: TMessage[];
+    }
+  | undefined;
+
 export type TForkConvoRequest = {
   messageId: string;
   conversationId: string;
@@ -301,63 +311,6 @@ export type TVerifyEmail = {
 
 export type TResendVerificationEmail = Omit<TVerifyEmail, 'token'>;
 
-export type TInterfaceConfig = {
-  privacyPolicy?: {
-    externalUrl?: string;
-    openNewTab?: boolean;
-  };
-  termsOfService?: {
-    externalUrl?: string;
-    openNewTab?: boolean;
-    modalAcceptance?: boolean;
-    modalTitle?: string;
-    modalContent?: string;
-  };
-  endpointsMenu: boolean;
-  modelSelect: boolean;
-  parameters: boolean;
-  sidePanel: boolean;
-  presets: boolean;
-  multiConvo: boolean;
-  bookmarks: boolean;
-  prompts: boolean;
-};
-
-export type TStartupConfig = {
-  appTitle: string;
-  socialLogins?: string[];
-  interface?: TInterfaceConfig;
-  discordLoginEnabled: boolean;
-  facebookLoginEnabled: boolean;
-  githubLoginEnabled: boolean;
-  googleLoginEnabled: boolean;
-  openidLoginEnabled: boolean;
-  openidLabel: string;
-  openidImageUrl: string;
-  /** LDAP Auth Configuration */
-  ldap?: {
-    /** LDAP enabled */
-    enabled: boolean;
-    /** Whether LDAP uses username vs. email */
-    username?: boolean;
-  };
-  serverDomain: string;
-  emailLoginEnabled: boolean;
-  registrationEnabled: boolean;
-  socialLoginEnabled: boolean;
-  passwordResetEnabled: boolean;
-  emailEnabled: boolean;
-  checkBalance: boolean;
-  showBirthdayIcon: boolean;
-  helpAndFaqURL: string;
-  customFooter?: string;
-  modelSpecs?: TSpecsConfig;
-  sharedLinksEnabled: boolean;
-  publicSharedLinksEnabled: boolean;
-  analyticsGtmId?: string;
-  instanceProjectId: string;
-};
-
 export type TRefreshTokenResponse = {
   token: string;
   user: TUser;
@@ -491,9 +444,7 @@ export type TUpdatePromptLabelsResponse = {
   message: string;
 };
 
-export type TDeletePromptGroupResponse = {
-  promptGroup: string;
-};
+export type TDeletePromptGroupResponse = TUpdatePromptLabelsResponse;
 
 export type TDeletePromptGroupRequest = {
   id: string;

package/src/zod.spec.ts

@@ -0,0 +1,467 @@
+/* eslint-disable jest/no-conditional-expect */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// zod.spec.ts
+import { z } from 'zod';
+import { convertJsonSchemaToZod } from './zod';
+import type { JsonSchemaType } from './zod';
+
+describe('convertJsonSchemaToZod', () => {
+  describe('primitive types', () => {
+    it('should convert string schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'string',
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse('test')).toBe('test');
+      expect(() => zodSchema.parse(123)).toThrow();
+    });
+
+    it('should convert string enum schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'string',
+        enum: ['foo', 'bar', 'baz'],
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse('foo')).toBe('foo');
+      expect(() => zodSchema.parse('invalid')).toThrow();
+    });
+
+    it('should convert number schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'number',
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse(123)).toBe(123);
+      expect(() => zodSchema.parse('123')).toThrow();
+    });
+
+    it('should convert boolean schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'boolean',
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse(true)).toBe(true);
+      expect(() => zodSchema.parse('true')).toThrow();
+    });
+  });
+
+  describe('array types', () => {
+    it('should convert array of strings schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'array',
+        items: { type: 'string' },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse(['a', 'b', 'c'])).toEqual(['a', 'b', 'c']);
+      expect(() => zodSchema.parse(['a', 123, 'c'])).toThrow();
+    });
+
+    it('should convert array of numbers schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'array',
+        items: { type: 'number' },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse([1, 2, 3])).toEqual([1, 2, 3]);
+      expect(() => zodSchema.parse([1, '2', 3])).toThrow();
+    });
+  });
+
+  describe('object types', () => {
+    it('should convert simple object schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse({ name: 'John', age: 30 })).toEqual({ name: 'John', age: 30 });
+      expect(() => zodSchema.parse({ name: 123, age: 30 })).toThrow();
+    });
+
+    it('should handle required fields', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+        },
+        required: ['name'],
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse({ name: 'John' })).toEqual({ name: 'John' });
+      expect(() => zodSchema.parse({})).toThrow();
+    });
+
+    it('should handle nested objects', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          user: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              age: { type: 'number' },
+            },
+            required: ['name'],
+          },
+        },
+        required: ['user'],
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse({ user: { name: 'John', age: 30 } })).toEqual({
+        user: { name: 'John', age: 30 },
+      });
+      expect(() => zodSchema.parse({ user: { age: 30 } })).toThrow();
+    });
+
+    it('should handle objects with arrays', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          names: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse({ names: ['John', 'Jane'] })).toEqual({ names: ['John', 'Jane'] });
+      expect(() => zodSchema.parse({ names: ['John', 123] })).toThrow();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty object schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {},
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse({})).toEqual({});
+    });
+
+    it('should handle unknown types as unknown', () => {
+      const schema = {
+        type: 'invalid',
+      } as unknown as JsonSchemaType;
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse('anything')).toBe('anything');
+      expect(zodSchema.parse(123)).toBe(123);
+    });
+
+    it('should handle empty enum arrays as regular strings', () => {
+      const schema: JsonSchemaType = {
+        type: 'string',
+        enum: [],
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      expect(zodSchema.parse('test')).toBe('test');
+    });
+  });
+
+  describe('complex schemas', () => {
+    it('should handle complex nested schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          id: { type: 'number' },
+          user: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              roles: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    name: { type: 'string' },
+                    permissions: {
+                      type: 'array',
+                      items: {
+                        type: 'string',
+                        enum: ['read', 'write', 'admin'],
+                      },
+                    },
+                  },
+                  required: ['name', 'permissions'],
+                },
+              },
+            },
+            required: ['name', 'roles'],
+          },
+        },
+        required: ['id', 'user'],
+      };
+
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      const validData = {
+        id: 1,
+        user: {
+          name: 'John',
+          roles: [
+            {
+              name: 'moderator',
+              permissions: ['read', 'write'],
+            },
+          ],
+        },
+      };
+
+      expect(zodSchema.parse(validData)).toEqual(validData);
+      expect(() =>
+        zodSchema.parse({
+          id: 1,
+          user: {
+            name: 'John',
+            roles: [
+              {
+                name: 'moderator',
+                permissions: ['invalid'],
+              },
+            ],
+          },
+        }),
+      ).toThrow();
+    });
+  });
+
+  // zod.spec.ts
+  describe('schema descriptions', () => {
+    it('should preserve top-level description', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        description: 'A test schema description',
+        properties: {
+          name: { type: 'string' },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+      expect(zodSchema.description).toBe('A test schema description');
+    });
+
+    it('should preserve field descriptions', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string',
+            description: 'The user\'s name',
+          },
+          age: {
+            type: 'number',
+            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');
+    });
+
+    it('should preserve descriptions in nested objects', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        description: 'User record',
+        properties: {
+          user: {
+            type: 'object',
+            description: 'User details',
+            properties: {
+              name: {
+                type: 'string',
+                description: 'The user\'s name',
+              },
+              settings: {
+                type: 'object',
+                description: 'User preferences',
+                properties: {
+                  theme: {
+                    type: 'string',
+                    description: 'UI theme preference',
+                    enum: ['light', 'dark'],
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      // Type assertions for better type safety
+      const shape = zodSchema instanceof z.ZodObject ? zodSchema.shape : {};
+      expect(zodSchema.description).toBe('User record');
+
+      if ('user' in shape) {
+        expect(shape.user.description).toBe('User details');
+
+        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.settings.description).toBe('User preferences');
+
+          const settingsShape =
+            userShape.settings instanceof z.ZodObject ? userShape.settings.shape : {};
+          if ('theme' in settingsShape) {
+            expect(settingsShape.theme.description).toBe('UI theme preference');
+          }
+        }
+      }
+    });
+
+    it('should preserve descriptions in arrays', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            description: 'User tags',
+            items: {
+              type: 'string',
+              description: 'Individual tag',
+            },
+          },
+          scores: {
+            type: 'array',
+            description: 'Test scores',
+            items: {
+              type: 'number',
+              description: 'Individual score',
+            },
+          },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      const shape = (zodSchema as z.ZodObject<any>).shape;
+      expect(shape.tags.description).toBe('User tags');
+      expect(shape.scores.description).toBe('Test scores');
+    });
+
+    it('should preserve descriptions in enums', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          role: {
+            type: 'string',
+            description: 'User role in the system',
+            enum: ['admin', 'user', 'guest'],
+          },
+          status: {
+            type: 'string',
+            description: 'Account status',
+            enum: ['active', 'suspended', 'deleted'],
+          },
+        },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      const shape = (zodSchema as z.ZodObject<any>).shape;
+      expect(shape.role.description).toBe('User role in the system');
+      expect(shape.status.description).toBe('Account status');
+    });
+
+    it('should preserve descriptions in a complex schema', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        description: 'User profile configuration',
+        properties: {
+          basicInfo: {
+            type: 'object',
+            description: 'Basic user information',
+            properties: {
+              name: {
+                type: 'string',
+                description: 'Full name of the user',
+              },
+              age: {
+                type: 'number',
+                description: 'User age in years',
+              },
+            },
+            required: ['name'],
+          },
+          preferences: {
+            type: 'object',
+            description: 'User preferences',
+            properties: {
+              notifications: {
+                type: 'array',
+                description: 'Notification settings',
+                items: {
+                  type: 'object',
+                  description: 'Individual notification preference',
+                  properties: {
+                    type: {
+                      type: 'string',
+                      description: 'Type of notification',
+                      enum: ['email', 'sms', 'push'],
+                    },
+                    enabled: {
+                      type: 'boolean',
+                      description: 'Whether this notification is enabled',
+                    },
+                  },
+                },
+              },
+              theme: {
+                type: 'string',
+                description: 'UI theme preference',
+                enum: ['light', 'dark', 'system'],
+              },
+            },
+          },
+        },
+      };
+
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      // Test top-level description
+      expect(zodSchema.description).toBe('User profile configuration');
+
+      const shape = zodSchema instanceof z.ZodObject ? zodSchema.shape : {};
+
+      // Test basic info descriptions
+      if ('basicInfo' in shape) {
+        expect(shape.basicInfo.description).toBe('Basic user information');
+        const basicInfoShape = shape.basicInfo instanceof z.ZodObject ? shape.basicInfo.shape : {};
+
+        if ('name' in basicInfoShape && 'age' in basicInfoShape) {
+          expect(basicInfoShape.name.description).toBe('Full name of the user');
+          expect(basicInfoShape.age.description).toBe('User age in years');
+        }
+      }
+
+      // Test preferences descriptions
+      if ('preferences' in shape) {
+        expect(shape.preferences.description).toBe('User preferences');
+        const preferencesShape =
+          shape.preferences instanceof z.ZodObject ? shape.preferences.shape : {};
+
+        if ('notifications' in preferencesShape && 'theme' in preferencesShape) {
+          expect(preferencesShape.notifications.description).toBe('Notification settings');
+          expect(preferencesShape.theme.description).toBe('UI theme preference');
+        }
+      }
+    });
+  });
+});

package/src/zod.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+
+export type JsonSchemaType = {
+  type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+  enum?: string[];
+  items?: JsonSchemaType;
+  properties?: Record<string, JsonSchemaType>;
+  required?: string[];
+  description?: string;
+};
+
+export function convertJsonSchemaToZod(schema: JsonSchemaType): z.ZodType {
+  let zodSchema: z.ZodType;
+
+  // Handle primitive types
+  if (schema.type === 'string') {
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+      const [first, ...rest] = schema.enum;
+      zodSchema = z.enum([first, ...rest] as [string, ...string[]]);
+    } else {
+      zodSchema = z.string();
+    }
+  } else if (schema.type === 'number') {
+    zodSchema = z.number();
+  } else if (schema.type === 'boolean') {
+    zodSchema = z.boolean();
+  } else if (schema.type === 'array' && schema.items !== undefined) {
+    const itemSchema = convertJsonSchemaToZod(schema.items);
+    zodSchema = z.array(itemSchema);
+  } else if (schema.type === 'object') {
+    const shape: Record<string, z.ZodType> = {};
+    const properties = schema.properties ?? {};
+
+    for (const [key, value] of Object.entries(properties)) {
+      let fieldSchema = convertJsonSchemaToZod(value);
+      if (value.description != null && value.description !== '') {
+        fieldSchema = fieldSchema.describe(value.description);
+      }
+      shape[key] = fieldSchema;
+    }
+
+    let objectSchema = z.object(shape);
+
+    if (Array.isArray(schema.required) && schema.required.length > 0) {
+      const partial = Object.fromEntries(
+        Object.entries(shape).map(([key, value]) => [
+          key,
+          schema.required?.includes(key) === true ? value : value.optional(),
+        ]),
+      );
+      objectSchema = z.object(partial);
+    } else {
+      objectSchema = objectSchema.partial();
+    }
+    zodSchema = objectSchema;
+  } else {
+    zodSchema = z.unknown();
+  }
+
+  // Add description if present
+  if (schema.description != null && schema.description !== '') {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+
+  return zodSchema;
+}