@lobehub/lobehub 2.0.0-next.40 → 2.0.0-next.42

package/packages/utils/src/trace.test.ts

@@ -0,0 +1,359 @@
+import { LOBE_CHAT_TRACE_HEADER, LOBE_CHAT_TRACE_ID } from '@lobechat/const';
+import { describe, expect, it } from 'vitest';
+
+import { createTraceHeader, getTraceId, getTracePayload } from './trace';
+
+describe('trace utilities', () => {
+  describe('getTracePayload', () => {
+    it('should extract and decode trace payload from request headers', () => {
+      const payload = {
+        traceId: '123-456-789',
+        sessionId: 'session-abc',
+        timestamp: 1234567890,
+      };
+
+      const encoded = Buffer.from(JSON.stringify(payload)).toString('base64');
+      const mockRequest = new Request('http://localhost', {
+        headers: {
+          [LOBE_CHAT_TRACE_HEADER]: encoded,
+        },
+      });
+
+      const result = getTracePayload(mockRequest);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should return undefined when trace header is not present', () => {
+      const mockRequest = new Request('http://localhost');
+
+      const result = getTracePayload(mockRequest);
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle empty trace header', () => {
+      const mockRequest = new Request('http://localhost', {
+        headers: {
+          [LOBE_CHAT_TRACE_HEADER]: '',
+        },
+      });
+
+      const result = getTracePayload(mockRequest);
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should decode complex payload with nested objects', () => {
+      const payload = {
+        traceId: 'trace-123',
+        metadata: {
+          user: { id: 'user-1', role: 'admin' },
+          context: { env: 'production', region: 'us-west-2' },
+        },
+        tags: ['important', 'production'],
+      };
+
+      const encoded = Buffer.from(JSON.stringify(payload)).toString('base64');
+      const mockRequest = new Request('http://localhost', {
+        headers: {
+          [LOBE_CHAT_TRACE_HEADER]: encoded,
+        },
+      });
+
+      const result = getTracePayload(mockRequest);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should handle payload with special characters', () => {
+      const payload = {
+        traceId: 'trace-with-特殊字符-🔥',
+        message: 'Test with émojis 😀',
+      };
+
+      const encoded = Buffer.from(JSON.stringify(payload)).toString('base64');
+      const mockRequest = new Request('http://localhost', {
+        headers: {
+          [LOBE_CHAT_TRACE_HEADER]: encoded,
+        },
+      });
+
+      const result = getTracePayload(mockRequest);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should handle payload with null values', () => {
+      const payload = {
+        traceId: 'trace-123',
+        optionalField: null,
+        anotherField: undefined,
+      };
+
+      const encoded = Buffer.from(JSON.stringify(payload)).toString('base64');
+      const mockRequest = new Request('http://localhost', {
+        headers: {
+          [LOBE_CHAT_TRACE_HEADER]: encoded,
+        },
+      });
+
+      const result = getTracePayload(mockRequest);
+
+      // Note: undefined values are removed during JSON.stringify
+      expect(result).toEqual({
+        traceId: 'trace-123',
+        optionalField: null,
+      });
+    });
+
+    it('should handle numeric and boolean values in payload', () => {
+      const payload = {
+        traceId: 'trace-123',
+        count: 42,
+        isActive: true,
+        ratio: 3.14159,
+        isDisabled: false,
+      };
+
+      const encoded = Buffer.from(JSON.stringify(payload)).toString('base64');
+      const mockRequest = new Request('http://localhost', {
+        headers: {
+          [LOBE_CHAT_TRACE_HEADER]: encoded,
+        },
+      });
+
+      const result = getTracePayload(mockRequest);
+
+      expect(result).toEqual(payload);
+    });
+  });
+
+  describe('getTraceId', () => {
+    it('should extract trace ID from response headers', () => {
+      const traceId = 'trace-xyz-789';
+      const mockResponse = new Response(null, {
+        headers: {
+          [LOBE_CHAT_TRACE_ID]: traceId,
+        },
+      });
+
+      const result = getTraceId(mockResponse);
+
+      expect(result).toBe(traceId);
+    });
+
+    it('should return null when trace ID header is not present', () => {
+      const mockResponse = new Response(null);
+
+      const result = getTraceId(mockResponse);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle empty trace ID', () => {
+      const mockResponse = new Response(null, {
+        headers: {
+          [LOBE_CHAT_TRACE_ID]: '',
+        },
+      });
+
+      const result = getTraceId(mockResponse);
+
+      expect(result).toBe('');
+    });
+
+    it('should handle trace ID with special characters', () => {
+      const traceId = 'trace-123-abc-特殊-🔥';
+      const mockResponse = new Response(null, {
+        headers: {
+          [LOBE_CHAT_TRACE_ID]: traceId,
+        },
+      });
+
+      const result = getTraceId(mockResponse);
+
+      expect(result).toBe(traceId);
+    });
+
+    it('should handle UUID-formatted trace IDs', () => {
+      const traceId = '550e8400-e29b-41d4-a716-446655440000';
+      const mockResponse = new Response(null, {
+        headers: {
+          [LOBE_CHAT_TRACE_ID]: traceId,
+        },
+      });
+
+      const result = getTraceId(mockResponse);
+
+      expect(result).toBe(traceId);
+    });
+  });
+
+  describe('createTraceHeader', () => {
+    it('should create a base64-encoded trace header from payload', () => {
+      const payload = {
+        traceId: 'trace-123',
+        sessionId: 'session-456',
+        timestamp: 1234567890,
+      };
+
+      const result = createTraceHeader(payload);
+
+      expect(result).toHaveProperty(LOBE_CHAT_TRACE_HEADER);
+      expect(typeof result[LOBE_CHAT_TRACE_HEADER]).toBe('string');
+
+      // Verify it's valid base64
+      const decoded = Buffer.from(result[LOBE_CHAT_TRACE_HEADER], 'base64').toString('utf8');
+      expect(JSON.parse(decoded)).toEqual(payload);
+    });
+
+    it('should create header for empty payload object', () => {
+      const payload = {};
+
+      const result = createTraceHeader(payload);
+
+      expect(result).toHaveProperty(LOBE_CHAT_TRACE_HEADER);
+
+      const decoded = Buffer.from(result[LOBE_CHAT_TRACE_HEADER], 'base64').toString('utf8');
+      expect(JSON.parse(decoded)).toEqual({});
+    });
+
+    it('should handle payload with nested objects', () => {
+      const payload = {
+        traceId: 'trace-123',
+        metadata: {
+          user: { id: 'user-1', name: 'John' },
+          context: { env: 'prod' },
+        },
+      };
+
+      const result = createTraceHeader(payload);
+
+      const decoded = Buffer.from(result[LOBE_CHAT_TRACE_HEADER], 'base64').toString('utf8');
+      expect(JSON.parse(decoded)).toEqual(payload);
+    });
+
+    it('should handle payload with arrays', () => {
+      const payload = {
+        traceId: 'trace-123',
+        tags: ['tag1', 'tag2', 'tag3'],
+        values: [1, 2, 3, 4, 5],
+      };
+
+      const result = createTraceHeader(payload);
+
+      const decoded = Buffer.from(result[LOBE_CHAT_TRACE_HEADER], 'base64').toString('utf8');
+      expect(JSON.parse(decoded)).toEqual(payload);
+    });
+
+    it('should handle payload with Unicode characters', () => {
+      const payload = {
+        traceId: 'trace-特殊-🔥',
+        message: 'Hello 世界 😀',
+        description: 'Тест тест',
+      };
+
+      const result = createTraceHeader(payload);
+
+      const decoded = Buffer.from(result[LOBE_CHAT_TRACE_HEADER], 'base64').toString('utf8');
+      expect(JSON.parse(decoded)).toEqual(payload);
+    });
+
+    it('should handle payload with null values', () => {
+      const payload = {
+        traceId: 'trace-123',
+        optionalField: null,
+      };
+
+      const result = createTraceHeader(payload);
+
+      const decoded = Buffer.from(result[LOBE_CHAT_TRACE_HEADER], 'base64').toString('utf8');
+      expect(JSON.parse(decoded)).toEqual(payload);
+    });
+
+    it('should handle payload with boolean and numeric values', () => {
+      const payload = {
+        traceId: 'trace-123',
+        count: 42,
+        isActive: true,
+        ratio: 3.14,
+        isDisabled: false,
+      };
+
+      const result = createTraceHeader(payload);
+
+      const decoded = Buffer.from(result[LOBE_CHAT_TRACE_HEADER], 'base64').toString('utf8');
+      expect(JSON.parse(decoded)).toEqual(payload);
+    });
+
+    it('should create header that works with getTracePayload', () => {
+      const payload = {
+        traceId: 'trace-round-trip',
+        sessionId: 'session-test',
+        timestamp: Date.now(),
+      };
+
+      const header = createTraceHeader(payload);
+      const mockRequest = new Request('http://localhost', {
+        headers: header,
+      });
+
+      const extractedPayload = getTracePayload(mockRequest);
+
+      expect(extractedPayload).toEqual(payload);
+    });
+  });
+
+  describe('round-trip encoding and decoding', () => {
+    it('should correctly encode and decode simple payload', () => {
+      const originalPayload = {
+        traceId: 'test-123',
+        data: 'test-data',
+      };
+
+      const header = createTraceHeader(originalPayload);
+      const mockRequest = new Request('http://localhost', { headers: header });
+      const decodedPayload = getTracePayload(mockRequest);
+
+      expect(decodedPayload).toEqual(originalPayload);
+    });
+
+    it('should correctly encode and decode complex payload', () => {
+      const originalPayload = {
+        traceId: 'complex-trace',
+        metadata: {
+          user: { id: 'usr-123', roles: ['admin', 'user'] },
+          timestamps: { created: 1234567890, updated: 1234567900 },
+        },
+        tags: ['production', 'critical'],
+        metrics: { duration: 123.45, count: 10 },
+        flags: { enabled: true, debug: false },
+      };
+
+      const header = createTraceHeader(originalPayload);
+      const mockRequest = new Request('http://localhost', { headers: header });
+      const decodedPayload = getTracePayload(mockRequest);
+
+      expect(decodedPayload).toEqual(originalPayload);
+    });
+
+    it('should preserve data types through encoding and decoding', () => {
+      const originalPayload = {
+        traceId: 'trace-types-test',
+        sessionId: 'session-123',
+        userId: 'user-456',
+        topicId: 'topic-789',
+        observationId: 'obs-abc',
+        enabled: true,
+        tags: ['tag1', 'tag2', 'tag3'],
+      };
+
+      const header = createTraceHeader(originalPayload);
+      const mockRequest = new Request('http://localhost', { headers: header });
+      const decodedPayload = getTracePayload(mockRequest);
+
+      expect(decodedPayload).toEqual(originalPayload);
+    });
+  });
+});

package/packages/utils/src/uriParser.ts

@@ -5,20 +5,20 @@ interface UriParserResult {
 }
 
 export const parseDataUri = (dataUri: string): UriParserResult => {
-  // 正则表达式匹配整个 Data URI 结构
+  // Regular expression to match the entire Data URI structure
   const dataUriMatch = dataUri.match(/^data:([^;]+);base64,(.+)$/);
 
   if (dataUriMatch) {
-    // 如果是合法的 Data URI
+    // If it's a valid Data URI
     return { base64: dataUriMatch[2], mimeType: dataUriMatch[1], type: 'base64' };
   }
 
   try {
     new URL(dataUri);
-    // 如果是合法的 URL
+    // If it's a valid URL
     return { base64: null, mimeType: null, type: 'url' };
   } catch {
-    // 既不是 Data URI 也不是合法 URL
+    // Neither a Data URI nor a valid URL
     return { base64: null, mimeType: null, type: null };
   }
 };

package/src/features/ChatItem/components/Title.tsx

@@ -1,5 +1,5 @@
 import dayjs from 'dayjs';
-import { memo } from 'react';
+import { CSSProperties, memo } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
 import { useStyles } from '../style';
@@ -10,6 +10,7 @@ export interface TitleProps {
   className?: string;
   placement?: ChatItemProps['placement'];
   showTitle?: ChatItemProps['showTitle'];
+  style?: CSSProperties;
   time?: ChatItemProps['time'];
   titleAddon?: ChatItemProps['titleAddon'];
 }
@@ -27,21 +28,24 @@ const formatTime = (time: number): string => {
   }
 };
 
-const Title = memo<TitleProps>(({ showTitle, placement, time, avatar, titleAddon, className }) => {
-  const { styles, cx } = useStyles({ placement, showTitle, time });
+const Title = memo<TitleProps>(
+  ({ showTitle, placement, time, avatar, titleAddon, className, style }) => {
+    const { styles, cx } = useStyles({ placement, showTitle, time });
 
-  return (
-    <Flexbox
-      align={'center'}
-      className={cx(styles.name, className)}
-      direction={placement === 'left' ? 'horizontal' : 'horizontal-reverse'}
-      gap={4}
-    >
-      {showTitle ? avatar.title || 'untitled' : undefined}
-      {showTitle ? titleAddon : undefined}
-      {time && <time>{formatTime(time)}</time>}
-    </Flexbox>
-  );
-});
+    return (
+      <Flexbox
+        align={'center'}
+        className={cx(styles.name, className)}
+        direction={placement === 'left' ? 'horizontal' : 'horizontal-reverse'}
+        gap={4}
+        style={style}
+      >
+        {showTitle ? avatar.title || 'untitled' : undefined}
+        {showTitle ? titleAddon : undefined}
+        {time && <time>{formatTime(time)}</time>}
+      </Flexbox>
+    );
+  },
+);
 
 export default Title;

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

@@ -4,6 +4,7 @@ import { LOADING_FLAT } from '@lobechat/const';
 import { UIChatMessage } from '@lobechat/types';
 import { Tag } from '@lobehub/ui';
 import { useResponsive } from 'antd-style';
+import isEqual from 'fast-deep-equal';
 import { ReactNode, memo, useCallback, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
@@ -213,12 +214,12 @@ const AssistantMessage = memo<AssistantMessageProps>((props) => {
           onClick={onAvatarClick}
           placement={placement}
           size={MOBILE_AVATAR_SIZE}
-          style={{ marginTop: 6 }}
         />
         <Title
           avatar={avatar}
           placement={placement}
           showTitle
+          style={{ marginBlockEnd: 0 }}
           time={createdAt}
           titleAddon={dmIndicator}
         />
@@ -274,6 +275,6 @@ const AssistantMessage = memo<AssistantMessageProps>((props) => {
       {mobile && <BorderSpacing borderSpacing={MOBILE_AVATAR_SIZE} />}
     </Flexbox>
   );
-});
+}, isEqual);
 
 export default AssistantMessage;

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

@@ -2,6 +2,7 @@
 
 import { UIChatMessage } from '@lobechat/types';
 import { useResponsive } from 'antd-style';
+import isEqual from 'fast-deep-equal';
 import { memo, useCallback } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
@@ -49,6 +50,7 @@ const GroupMessage = memo<GroupMessageProps>((props) => {
     provider,
   } = props;
   const avatar = meta;
+  console.log('render');
   const { mobile } = useResponsive();
   const placement = 'left';
   const type = useAgentStore(agentChatConfigSelectors.displayMode);
@@ -96,9 +98,14 @@ const GroupMessage = memo<GroupMessageProps>((props) => {
           onClick={onAvatarClick}
           placement={placement}
           size={MOBILE_AVATAR_SIZE}
-          style={{ marginTop: 6 }}
         />
-        <Title avatar={avatar} placement={placement} showTitle time={createdAt} />
+        <Title
+          avatar={avatar}
+          placement={placement}
+          showTitle
+          style={{ marginBlockEnd: 0 }}
+          time={createdAt}
+        />
       </Flexbox>
       {isEditing && contentId ? (
         <EditState content={lastAssistantMsg?.content} id={contentId} />
@@ -141,6 +148,6 @@ const GroupMessage = memo<GroupMessageProps>((props) => {
       {mobile && <BorderSpacing borderSpacing={MOBILE_AVATAR_SIZE} />}
     </Flexbox>
   );
-});
+}, isEqual);
 
 export default GroupMessage;

package/src/server/services/message/index.ts

@@ -1,5 +1,5 @@
 import { LobeChatDatabase } from '@lobechat/database';
-import { CreateMessageParams, UpdateMessageParams } from '@lobechat/types';
+import { CreateMessageParams, UIChatMessage, UpdateMessageParams } from '@lobechat/types';
 
 import { MessageModel } from '@/database/models/message';
 
@@ -51,7 +51,9 @@ export class MessageService {
   /**
    * Query messages and return response with success status (used after mutations)
    */
-  private async queryWithSuccess(options?: QueryOptions) {
+  private async queryWithSuccess(
+    options?: QueryOptions,
+  ): Promise<{ messages?: UIChatMessage[], success: boolean; }> {
     if (!options || (options.sessionId === undefined && options.topicId === undefined)) {
       return { success: true };
     }
@@ -139,7 +141,11 @@ export class MessageService {
    * Update plugin state and return message list
    * Pattern: update + conditional query
    */
-  async updatePluginState(id: string, value: any, options: QueryOptions): Promise<any> {
+  async updatePluginState(
+    id: string,
+    value: any,
+    options: QueryOptions,
+  ): Promise<{ messages?: UIChatMessage[], success: boolean; }> {
     await this.messageModel.updatePluginState(id, value);
     return this.queryWithSuccess(options);
   }
@@ -148,7 +154,11 @@ export class MessageService {
    * Update message and return message list
    * Pattern: update + conditional query
    */
-  async updateMessage(id: string, value: UpdateMessageParams, options: QueryOptions): Promise<any> {
+  async updateMessage(
+    id: string,
+    value: UpdateMessageParams,
+    options: QueryOptions,
+  ): Promise<{ messages?: UIChatMessage[], success: boolean; }> {
     await this.messageModel.update(id, value as any);
     return this.queryWithSuccess(options);
   }

package/src/store/chat/slices/aiChat/actions/conversationLifecycle.ts

@@ -166,7 +166,11 @@ export const conversationLifecycle: StateCreator<
         topicId = data.topicId;
       }
 
-      get().replaceMessages(data.messages, { sessionId: activeId, topicId: topicId });
+      get().replaceMessages(data.messages, {
+        sessionId: activeId,
+        topicId: topicId,
+        action: 'sendMessage/serverResponse',
+      });
 
       if (data.isCreateNewTopic && data.topicId) {
         await get().switchTopic(data.topicId, true);
@@ -250,7 +254,9 @@ export const conversationLifecycle: StateCreator<
         .map((f) => f?.id)
         .filter(Boolean) as string[];
 
-      await getAgentStoreState().addFilesToAgent(userFiles, false);
+      if (userFiles.length > 0) {
+        await getAgentStoreState().addFilesToAgent(userFiles, false);
+      }
     } catch (e) {
       console.error(e);
     } finally {

package/src/store/chat/slices/aiChat/actions/streamingExecutor.ts

@@ -521,10 +521,7 @@ export const streamingExecutor: StateCreator<
       // Handle completion and error events
       for (const event of result.events) {
         if (event.type === 'done') {
-          log('[internal_execAgentRuntime] Received done event, syncing to database');
-          // Sync final state to database
-          const finalMessages = get().messagesMap[messageKey] || [];
-          get().replaceMessages(finalMessages);
+          log('[internal_execAgentRuntime] Received done event');
         }
 
         if (event.type === 'error') {

package/src/store/chat/slices/message/actions/optimisticUpdate.ts

@@ -195,7 +195,7 @@ export const messageOptimisticUpdate: StateCreator<
     );
 
     if (result && result.success && result.messages) {
-      replaceMessages(result.messages);
+      replaceMessages(result.messages, { action: 'optimisticUpdateMessageContent' });
     } else {
       await refreshMessages();
     }