@lobehub/chat 1.140.0 → 1.141.1

package/packages/model-runtime/src/providers/groq/index.test.ts

@@ -33,6 +33,455 @@ afterEach(() => {
 });
 
 describe('LobeGroq - custom features', () => {
+  describe('filterAdvancedFields', () => {
+    const filterAdvancedFields = params.generateObject!.handleSchema!;
+
+    it('should filter out maxItems from schema', () => {
+      const schema = {
+        items: { type: 'string' },
+        maxItems: 5,
+        type: 'array',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        items: { type: 'string' },
+        type: 'array',
+      });
+      expect(result.maxItems).toBeUndefined();
+    });
+
+    it('should filter out minItems from schema', () => {
+      const schema = {
+        items: { type: 'string' },
+        minItems: 2,
+        type: 'array',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        items: { type: 'string' },
+        type: 'array',
+      });
+      expect(result.minItems).toBeUndefined();
+    });
+
+    it('should filter out maxLength from schema', () => {
+      const schema = {
+        maxLength: 100,
+        type: 'string',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'string',
+      });
+      expect(result.maxLength).toBeUndefined();
+    });
+
+    it('should filter out minLength from schema', () => {
+      const schema = {
+        minLength: 5,
+        type: 'string',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'string',
+      });
+      expect(result.minLength).toBeUndefined();
+    });
+
+    it('should filter out pattern from schema', () => {
+      const schema = {
+        pattern: '^[a-z]+$',
+        type: 'string',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'string',
+      });
+      expect(result.pattern).toBeUndefined();
+    });
+
+    it('should filter out format from schema', () => {
+      const schema = {
+        format: 'email',
+        type: 'string',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'string',
+      });
+      expect(result.format).toBeUndefined();
+    });
+
+    it('should filter out uniqueItems from schema', () => {
+      const schema = {
+        items: { type: 'number' },
+        type: 'array',
+        uniqueItems: true,
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        items: { type: 'number' },
+        type: 'array',
+      });
+      expect(result.uniqueItems).toBeUndefined();
+    });
+
+    it('should filter out maxProperties from schema', () => {
+      const schema = {
+        maxProperties: 10,
+        type: 'object',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'object',
+      });
+      expect(result.maxProperties).toBeUndefined();
+    });
+
+    it('should filter out minProperties from schema', () => {
+      const schema = {
+        minProperties: 2,
+        type: 'object',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'object',
+      });
+      expect(result.minProperties).toBeUndefined();
+    });
+
+    it('should filter out multipleOf from schema', () => {
+      const schema = {
+        multipleOf: 5,
+        type: 'number',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'number',
+      });
+      expect(result.multipleOf).toBeUndefined();
+    });
+
+    it('should filter out maximum from schema', () => {
+      const schema = {
+        maximum: 100,
+        type: 'number',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'number',
+      });
+      expect(result.maximum).toBeUndefined();
+    });
+
+    it('should filter out minimum from schema', () => {
+      const schema = {
+        minimum: 0,
+        type: 'number',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'number',
+      });
+      expect(result.minimum).toBeUndefined();
+    });
+
+    it('should filter out exclusiveMaximum from schema', () => {
+      const schema = {
+        exclusiveMaximum: 100,
+        type: 'number',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'number',
+      });
+      expect(result.exclusiveMaximum).toBeUndefined();
+    });
+
+    it('should filter out exclusiveMinimum from schema', () => {
+      const schema = {
+        exclusiveMinimum: 0,
+        type: 'number',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'number',
+      });
+      expect(result.exclusiveMinimum).toBeUndefined();
+    });
+
+    it('should filter out multiple unsupported properties at once', () => {
+      const schema = {
+        format: 'email',
+        maxLength: 100,
+        minLength: 5,
+        pattern: '^[a-z]+$',
+        type: 'string',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        type: 'string',
+      });
+      expect(result.maxLength).toBeUndefined();
+      expect(result.minLength).toBeUndefined();
+      expect(result.pattern).toBeUndefined();
+      expect(result.format).toBeUndefined();
+    });
+
+    it('should preserve supported properties', () => {
+      const schema = {
+        description: 'A test field',
+        enum: ['a', 'b', 'c'],
+        maxLength: 10,
+        type: 'string',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        description: 'A test field',
+        enum: ['a', 'b', 'c'],
+        type: 'string',
+      });
+    });
+
+    it('should handle nested objects recursively', () => {
+      const schema = {
+        properties: {
+          email: {
+            format: 'email',
+            maxLength: 100,
+            type: 'string',
+          },
+          name: {
+            minLength: 2,
+            type: 'string',
+          },
+        },
+        type: 'object',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        properties: {
+          email: {
+            type: 'string',
+          },
+          name: {
+            type: 'string',
+          },
+        },
+        type: 'object',
+      });
+    });
+
+    it('should handle deeply nested objects', () => {
+      const schema = {
+        properties: {
+          user: {
+            properties: {
+              address: {
+                maxProperties: 5,
+                properties: {
+                  city: {
+                    maxLength: 50,
+                    type: 'string',
+                  },
+                  zip: {
+                    pattern: '^\\d{5}$',
+                    type: 'string',
+                  },
+                },
+                type: 'object',
+              },
+              name: {
+                minLength: 1,
+                type: 'string',
+              },
+            },
+            type: 'object',
+          },
+        },
+        type: 'object',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        properties: {
+          user: {
+            properties: {
+              address: {
+                properties: {
+                  city: {
+                    type: 'string',
+                  },
+                  zip: {
+                    type: 'string',
+                  },
+                },
+                type: 'object',
+              },
+              name: {
+                type: 'string',
+              },
+            },
+            type: 'object',
+          },
+        },
+        type: 'object',
+      });
+    });
+
+    it('should handle arrays in schema', () => {
+      const schema = {
+        items: {
+          maxLength: 50,
+          type: 'string',
+        },
+        maxItems: 10,
+        minItems: 1,
+        type: 'array',
+        uniqueItems: true,
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        items: {
+          type: 'string',
+        },
+        type: 'array',
+      });
+    });
+
+    it('should handle arrays of objects', () => {
+      const schema = {
+        items: {
+          properties: {
+            age: {
+              maximum: 120,
+              minimum: 0,
+              type: 'number',
+            },
+            name: {
+              maxLength: 100,
+              type: 'string',
+            },
+          },
+          type: 'object',
+        },
+        type: 'array',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        items: {
+          properties: {
+            age: {
+              type: 'number',
+            },
+            name: {
+              type: 'string',
+            },
+          },
+          type: 'object',
+        },
+        type: 'array',
+      });
+    });
+
+    it('should handle null values', () => {
+      const result = filterAdvancedFields(null);
+      expect(result).toBeNull();
+    });
+
+    it('should handle primitive values', () => {
+      expect(filterAdvancedFields('string')).toBe('string');
+      expect(filterAdvancedFields(123)).toBe(123);
+      expect(filterAdvancedFields(true)).toBe(true);
+    });
+
+    it('should handle empty objects', () => {
+      const schema = {};
+      const result = filterAdvancedFields(schema);
+      expect(result).toEqual({});
+    });
+
+    it('should preserve required and other common fields', () => {
+      const schema = {
+        additionalProperties: false,
+        description: 'A person object',
+        maxProperties: 10,
+        properties: {
+          age: {
+            description: 'Person age',
+            maximum: 150,
+            type: 'number',
+          },
+          name: {
+            description: 'Person name',
+            maxLength: 100,
+            type: 'string',
+          },
+        },
+        required: ['name', 'age'],
+        type: 'object',
+      };
+
+      const result = filterAdvancedFields(schema);
+
+      expect(result).toEqual({
+        additionalProperties: false,
+        description: 'A person object',
+        properties: {
+          age: {
+            description: 'Person age',
+            type: 'number',
+          },
+          name: {
+            description: 'Person name',
+            type: 'string',
+          },
+        },
+        required: ['name', 'age'],
+        type: 'object',
+      });
+    });
+  });
+
   describe('Debug Configuration', () => {
     it('should disable debug by default', () => {
       delete process.env.DEBUG_GROQ_CHAT_COMPLETION;

package/packages/model-runtime/src/providers/groq/index.ts

@@ -13,6 +13,49 @@ export interface GroqModelCard {
   id: string;
 }
 
+/**
+ * Filter out advanced JSON Schema properties that Groq doesn't support
+ */
+const filterAdvancedFields = (schema: any): any => {
+  if (typeof schema !== 'object' || schema === null) {
+    return schema;
+  }
+
+  if (Array.isArray(schema)) {
+    return schema.map(filterAdvancedFields);
+  }
+
+  const filtered: any = {};
+
+  // List of advanced properties to filter out
+  const unsupportedProperties = new Set([
+    'maxItems',
+    'minItems',
+    'maxLength',
+    'minLength',
+    'pattern',
+    'format',
+    'uniqueItems',
+    'maxProperties',
+    'minProperties',
+    'multipleOf',
+    'maximum',
+    'minimum',
+    'exclusiveMaximum',
+    'exclusiveMinimum',
+  ]);
+
+  for (const [key, value] of Object.entries(schema)) {
+    if (unsupportedProperties.has(key)) {
+      continue;
+    }
+
+    filtered[key] = filterAdvancedFields(value);
+  }
+
+  return filtered;
+};
+
 export const params = {
   baseURL: 'https://api.groq.com/openai/v1',
   chatCompletion: {
@@ -40,6 +83,9 @@ export const params = {
   debug: {
     chatCompletion: () => process.env.DEBUG_GROQ_CHAT_COMPLETION === '1',
   },
+  generateObject: {
+    handleSchema: filterAdvancedFields,
+  },
   models: async ({ client }) => {
     const { LOBE_DEFAULT_MODEL_LIST } = await import('model-bank');
 

package/src/app/[variants]/(main)/_layout/Desktop/SideBar/TopActions.tsx

@@ -24,6 +24,7 @@ export interface TopActionProps {
   tab?: SidebarTabKey;
 }
 
+//  TODO Change icons
 const TopActions = memo<TopActionProps>(({ tab, isPinned }) => {
   const { t } = useTranslation('common');
   const switchBackToChat = useGlobalStore((s) => s.switchBackToChat);
@@ -66,12 +67,12 @@ const TopActions = memo<TopActionProps>(({ tab, isPinned }) => {
         />
       </Link>
       {enableKnowledgeBase && (
-        <Link aria-label={t('tab.files')} href={'/files'}>
+        <Link aria-label={t('tab.knowledgeBase')} href={'/files'}>
           <ActionIcon
             active={isFilesActive}
             icon={FolderClosed}
             size={ICON_SIZE}
-            title={t('tab.files')}
+            title={t('tab.knowledgeBase')}
             tooltipProps={{ placement: 'right' }}
           />
         </Link>

package/src/app/[variants]/(main)/chat/(workspace)/_layout/Desktop/ChatHeader/Tags/index.tsx

@@ -28,7 +28,7 @@ const TitleTags = memo(() => {
     agentSelectors.isAgentConfigLoading(s),
   ]);
 
-  const plugins = useAgentStore(agentSelectors.currentAgentPlugins, isEqual);
+  const plugins = useAgentStore(agentSelectors.displayableAgentPlugins, isEqual);
   const enabledKnowledge = useAgentStore(agentSelectors.currentEnabledKnowledge, isEqual);
   const enableHistoryCount = useAgentStore(agentChatConfigSelectors.enableHistoryCount);
 

package/src/app/[variants]/(main)/files/(content)/@menu/features/KnowledgeBase/Item/index.tsx

@@ -1,8 +1,10 @@
 import { createStyles } from 'antd-style';
 import Link from 'next/link';
-import { memo, useState } from 'react';
+import React, { memo, useState } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
+import { useQueryRoute } from '@/hooks/useQueryRoute';
+
 import Content, { knowledgeItemClass } from './Content';
 
 const useStyles = createStyles(({ css, token, isDarkMode }) => ({
@@ -44,9 +46,15 @@ export interface KnowledgeBaseItemProps {
 const KnowledgeBaseItem = memo<KnowledgeBaseItemProps>(({ name, active, id }) => {
   const { styles, cx } = useStyles();
   const [isHover, setHovering] = useState(false);
+  const router = useQueryRoute();
+
+  const handleClick = (e: React.MouseEvent) => {
+    e.preventDefault();
+    router.push(`/repos/${id}`);
+  };
 
   return (
-    <Link href={`/repos/${id}`}>
+    <Link href={`/repos/${id}`} onClick={handleClick}>
       <Flexbox
         align={'center'}
         className={cx(styles.container, knowledgeItemClass, active && styles.active)}

package/src/features/ChatInput/InputEditor/index.tsx

@@ -7,6 +7,7 @@ import {
   ReactCodePlugin,
   ReactCodeblockPlugin,
   ReactHRPlugin,
+  ReactLinkHighlightPlugin,
   ReactListPlugin,
   ReactMathPlugin,
   ReactTablePlugin,
@@ -92,6 +93,7 @@ const InputEditor = memo<{ defaultRows?: number }>(({ defaultRows = 2 }) => {
               ReactCodePlugin,
               ReactCodeblockPlugin,
               ReactHRPlugin,
+              ReactLinkHighlightPlugin,
               ReactTablePlugin,
               Editor.withProps(ReactMathPlugin, {
                 renderComp: expand

package/src/features/Conversation/Messages/User/index.tsx

@@ -44,18 +44,8 @@ const remarkPlugins = markdownElements
   .filter(Boolean);
 
 const UserMessage = memo<UserMessageProps>((props) => {
-  const {
-    id,
-    ragQuery,
-    content,
-    createdAt,
-    error,
-    role,
-    index,
-    extra,
-    disableEditing,
-    targetId,
-  } = props;
+  const { id, ragQuery, content, createdAt, error, role, index, extra, disableEditing, targetId } =
+    props;
 
   const { t } = useTranslation('chat');
   const { mobile } = useResponsive();
@@ -71,14 +61,14 @@ const UserMessage = memo<UserMessageProps>((props) => {
   ]);
 
   const loading = isInRAGFlow || generating;
-  
+
   // Get target name for DM indicator
   const userName = useUserStore(userProfileSelectors.nickName) || 'User';
   const agents = useSessionStore(sessionSelectors.currentGroupAgents);
-  
+
   const dmIndicator = useMemo(() => {
     if (!targetId) return undefined;
-    
+
     let targetName = targetId;
     if (targetId === 'user') {
       targetName = userName;
@@ -86,7 +76,7 @@ const UserMessage = memo<UserMessageProps>((props) => {
       const targetAgent = agents?.find((agent) => agent.id === targetId);
       targetName = targetAgent?.title || targetId;
     }
-    
+
     return <Tag>{t('dm.visibleTo', { target: targetName })}</Tag>;
   }, [targetId, userName, agents, t]);
 
@@ -167,7 +157,7 @@ const UserMessage = memo<UserMessageProps>((props) => {
           direction={placement === 'left' ? 'horizontal' : 'horizontal-reverse'}
           gap={8}
         >
-          <Flexbox flex={1} style={{ minWidth: 0 }}>
+          <Flexbox flex={1} style={{ maxWidth: '100%', minWidth: 0 }}>
             <MessageContent
               editing={editing}
               id={id}