@lobehub/lobehub 2.0.0-next.266 → 2.0.0-next.268

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

@@ -0,0 +1,302 @@
+import { MessageContentPart } from '@lobechat/types';
+import { describe, expect, it } from 'vitest';
+
+import { deserializeParts, serializePartsForStorage } from './multimodalContent';
+
+describe('multimodalContent', () => {
+  describe('serializePartsForStorage', () => {
+    it('should serialize text content part to JSON string', () => {
+      const parts: MessageContentPart[] = [
+        {
+          type: 'text',
+          text: 'Hello, world!',
+        },
+      ];
+
+      const result = serializePartsForStorage(parts);
+
+      expect(result).toBe('[{"type":"text","text":"Hello, world!"}]');
+      expect(typeof result).toBe('string');
+    });
+
+    it('should serialize image content part to JSON string', () => {
+      const parts: MessageContentPart[] = [
+        {
+          type: 'image',
+          image: 'data:image/png;base64,iVBORw0KGgoAAAANS',
+        },
+      ];
+
+      const result = serializePartsForStorage(parts);
+
+      expect(result).toBe('[{"type":"image","image":"data:image/png;base64,iVBORw0KGgoAAAANS"}]');
+    });
+
+    it('should serialize multiple content parts to JSON string', () => {
+      const parts: MessageContentPart[] = [
+        {
+          type: 'text',
+          text: 'Check this image:',
+        },
+        {
+          type: 'image',
+          image: 'data:image/png;base64,abc123',
+        },
+        {
+          type: 'text',
+          text: 'What do you think?',
+        },
+      ];
+
+      const result = serializePartsForStorage(parts);
+      const parsed = JSON.parse(result);
+
+      expect(Array.isArray(parsed)).toBe(true);
+      expect(parsed).toHaveLength(3);
+      expect(parsed[0].type).toBe('text');
+      expect(parsed[1].type).toBe('image');
+      expect(parsed[2].type).toBe('text');
+    });
+
+    it('should serialize content parts with thoughtSignature', () => {
+      const parts: MessageContentPart[] = [
+        {
+          type: 'text',
+          text: 'Reasoning content',
+          thoughtSignature: 'sig-123',
+        },
+      ];
+
+      const result = serializePartsForStorage(parts);
+      const parsed = JSON.parse(result);
+
+      expect(parsed[0].thoughtSignature).toBe('sig-123');
+    });
+
+    it('should handle empty array', () => {
+      const parts: MessageContentPart[] = [];
+
+      const result = serializePartsForStorage(parts);
+
+      expect(result).toBe('[]');
+    });
+
+    it('should handle special characters in text', () => {
+      const parts: MessageContentPart[] = [
+        {
+          type: 'text',
+          text: 'Hello "world"!\nNew line\tTab\r\nWindows line',
+        },
+      ];
+
+      const result = serializePartsForStorage(parts);
+      const parsed = JSON.parse(result);
+
+      expect(parsed[0].text).toBe('Hello "world"!\nNew line\tTab\r\nWindows line');
+    });
+
+    it('should handle unicode characters', () => {
+      const parts: MessageContentPart[] = [
+        {
+          type: 'text',
+          text: '你好世界 🌍 مرحبا بالعالم',
+        },
+      ];
+
+      const result = serializePartsForStorage(parts);
+      const parsed = JSON.parse(result);
+
+      expect(parsed[0].text).toBe('你好世界 🌍 مرحبا بالعالم');
+    });
+  });
+
+  describe('deserializeParts', () => {
+    it('should deserialize valid JSON string to content parts', () => {
+      const jsonString = '[{"type":"text","text":"Hello, world!"}]';
+
+      const result = deserializeParts(jsonString);
+
+      expect(result).not.toBeNull();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(1);
+      expect(result![0].type).toBe('text');
+      if (result![0].type === 'text') {
+        expect(result![0].text).toBe('Hello, world!');
+      }
+    });
+
+    it('should deserialize multiple content parts', () => {
+      const jsonString =
+        '[{"type":"text","text":"Check this:"},{"type":"image","image":"data:image/png"}]';
+
+      const result = deserializeParts(jsonString);
+
+      expect(result).not.toBeNull();
+      expect(result).toHaveLength(2);
+      expect(result![0].type).toBe('text');
+      expect(result![1].type).toBe('image');
+    });
+
+    it('should deserialize content parts with thoughtSignature', () => {
+      const jsonString = '[{"type":"text","text":"Reasoning","thoughtSignature":"sig-123"}]';
+
+      const result = deserializeParts(jsonString);
+
+      expect(result).not.toBeNull();
+      if (result![0].type === 'text') {
+        expect(result![0].thoughtSignature).toBe('sig-123');
+      }
+    });
+
+    it('should return null for invalid JSON', () => {
+      const invalidJSON = '{not valid json}';
+
+      const result = deserializeParts(invalidJSON);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for empty string', () => {
+      const result = deserializeParts('');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for plain text string', () => {
+      const plainText = 'Just a plain text message';
+
+      const result = deserializeParts(plainText);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for empty array', () => {
+      const emptyArray = '[]';
+
+      const result = deserializeParts(emptyArray);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for array without type property', () => {
+      const invalidParts = '[{"text":"Hello"}]';
+
+      const result = deserializeParts(invalidParts);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for non-array JSON', () => {
+      const objectJSON = '{"type":"text","text":"Hello"}';
+
+      const result = deserializeParts(objectJSON);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for array of primitives', () => {
+      const primitiveArray = '[1, 2, 3, "text"]';
+
+      const result = deserializeParts(primitiveArray);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle malformed JSON gracefully', () => {
+      const malformedJSON = '[{"type":"text","text":}]';
+
+      const result = deserializeParts(malformedJSON);
+
+      expect(result).toBeNull();
+    });
+
+    it('should deserialize content with special characters', () => {
+      const jsonString = '[{"type":"text","text":"Hello \\"world\\"!\\nNew line"}]';
+
+      const result = deserializeParts(jsonString);
+
+      expect(result).not.toBeNull();
+      if (result![0].type === 'text') {
+        expect(result![0].text).toBe('Hello "world"!\nNew line');
+      }
+    });
+
+    it('should deserialize content with unicode characters', () => {
+      const jsonString = '[{"type":"text","text":"你好世界 🌍"}]';
+
+      const result = deserializeParts(jsonString);
+
+      expect(result).not.toBeNull();
+      if (result![0].type === 'text') {
+        expect(result![0].text).toBe('你好世界 🌍');
+      }
+    });
+  });
+
+  describe('round-trip serialization', () => {
+    it('should maintain data integrity for text parts', () => {
+      const originalParts: MessageContentPart[] = [
+        {
+          type: 'text',
+          text: 'Original text content',
+        },
+      ];
+
+      const serialized = serializePartsForStorage(originalParts);
+      const deserialized = deserializeParts(serialized);
+
+      expect(deserialized).toEqual(originalParts);
+    });
+
+    it('should maintain data integrity for image parts', () => {
+      const originalParts: MessageContentPart[] = [
+        {
+          type: 'image',
+          image: 'data:image/png;base64,abc123',
+        },
+      ];
+
+      const serialized = serializePartsForStorage(originalParts);
+      const deserialized = deserializeParts(serialized);
+
+      expect(deserialized).toEqual(originalParts);
+    });
+
+    it('should maintain data integrity for mixed content', () => {
+      const originalParts: MessageContentPart[] = [
+        {
+          type: 'text',
+          text: 'Text before image',
+          thoughtSignature: 'sig-1',
+        },
+        {
+          type: 'image',
+          image: 'data:image/png;base64,xyz789',
+        },
+        {
+          type: 'text',
+          text: 'Text after image',
+        },
+      ];
+
+      const serialized = serializePartsForStorage(originalParts);
+      const deserialized = deserializeParts(serialized);
+
+      expect(deserialized).toEqual(originalParts);
+    });
+
+    it('should maintain data integrity for complex text with special characters', () => {
+      const originalParts: MessageContentPart[] = [
+        {
+          type: 'text',
+          text: 'Complex text:\n- Line 1\n- "Quoted"\n- Tab:\t<-\n- Unicode: 你好 🌍',
+        },
+      ];
+
+      const serialized = serializePartsForStorage(originalParts);
+      const deserialized = deserializeParts(serialized);
+
+      expect(deserialized).toEqual(originalParts);
+    });
+  });
+});

package/packages/utils/src/server/__tests__/sse.test.ts

@@ -0,0 +1,353 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createSSEHeaders, createSSEWriter, formatSSEEvent } from '../sse';
+
+describe('formatSSEEvent', () => {
+  it('should format SSE event with data only', () => {
+    const result = formatSSEEvent({ data: 'test message' });
+
+    expect(result).toBe('data: test message\n\n');
+  });
+
+  it('should format SSE event with all fields', () => {
+    const result = formatSSEEvent({
+      data: { message: 'hello' },
+      event: 'custom-event',
+      id: 'event-123',
+      retry: 3000,
+    });
+
+    expect(result).toBe(
+      'id: event-123\nevent: custom-event\nretry: 3000\ndata: {"message":"hello"}\n\n',
+    );
+  });
+
+  it('should serialize object data to JSON', () => {
+    const result = formatSSEEvent({
+      data: { foo: 'bar', count: 42 },
+    });
+
+    expect(result).toBe('data: {"foo":"bar","count":42}\n\n');
+  });
+
+  it('should handle multi-line string data', () => {
+    const result = formatSSEEvent({
+      data: 'line1\nline2\nline3',
+    });
+
+    expect(result).toBe('data: line1\ndata: line2\ndata: line3\n\n');
+  });
+
+  it('should handle empty string data', () => {
+    const result = formatSSEEvent({ data: '' });
+
+    expect(result).toBe('data: \n\n');
+  });
+
+  it('should format event with id only', () => {
+    const result = formatSSEEvent({
+      data: 'test',
+      id: 'msg-001',
+    });
+
+    expect(result).toBe('id: msg-001\ndata: test\n\n');
+  });
+
+  it('should format event with event type only', () => {
+    const result = formatSSEEvent({
+      data: 'test',
+      event: 'notification',
+    });
+
+    expect(result).toBe('event: notification\ndata: test\n\n');
+  });
+
+  it('should format event with retry only', () => {
+    const result = formatSSEEvent({
+      data: 'test',
+      retry: 5000,
+    });
+
+    expect(result).toBe('retry: 5000\ndata: test\n\n');
+  });
+
+  it('should handle numeric data', () => {
+    const result = formatSSEEvent({
+      data: 42,
+    });
+
+    expect(result).toBe('data: 42\n\n');
+  });
+
+  it('should handle boolean data', () => {
+    const result = formatSSEEvent({
+      data: true,
+    });
+
+    expect(result).toBe('data: true\n\n');
+  });
+
+  it('should handle null data', () => {
+    const result = formatSSEEvent({
+      data: null,
+    });
+
+    expect(result).toBe('data: null\n\n');
+  });
+
+  it('should handle array data', () => {
+    const result = formatSSEEvent({
+      data: [1, 2, 3],
+    });
+
+    expect(result).toBe('data: [1,2,3]\n\n');
+  });
+
+  it('should handle nested object data', () => {
+    const result = formatSSEEvent({
+      data: {
+        user: {
+          name: 'Alice',
+          profile: {
+            age: 30,
+          },
+        },
+      },
+    });
+
+    expect(result).toBe('data: {"user":{"name":"Alice","profile":{"age":30}}}\n\n');
+  });
+});
+
+describe('createSSEWriter', () => {
+  describe('writeConnection', () => {
+    it('should write connection event with required fields', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+      const timestamp = 1234567890;
+
+      writer.writeConnection('op-123', 'last-event-456', timestamp);
+
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        'id: conn_1234567890\nevent: connected\ndata: {"lastEventId":"last-event-456","operationId":"op-123","timestamp":1234567890,"type":"connected"}\n\n',
+      );
+    });
+
+    it('should use Date.now() when timestamp is not provided', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+      const now = Date.now();
+
+      writer.writeConnection('op-456', 'last-789');
+
+      const call = mockController.enqueue.mock.calls[0]![0];
+      expect(call).toContain('event: connected');
+      expect(call).toContain('"operationId":"op-456"');
+      expect(call).toContain('"lastEventId":"last-789"');
+      expect(call).toMatch(/"timestamp":\d+/);
+    });
+  });
+
+  describe('writeError', () => {
+    it('should write error event with Error object', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+      const error = new Error('Something went wrong');
+      error.stack = 'Error: Something went wrong\n  at test.ts:10';
+      const timestamp = 1234567890;
+
+      writer.writeError(error, 'op-999', 'processing', timestamp);
+
+      expect(mockController.enqueue).toHaveBeenCalledWith(expect.stringContaining('event: error'));
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        expect.stringContaining('"error":"Something went wrong"'),
+      );
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        expect.stringContaining('"phase":"processing"'),
+      );
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        expect.stringContaining('"stack":"Error: Something went wrong'),
+      );
+    });
+
+    it('should write error event without stack trace when not available', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+      const error = new Error('No stack');
+      delete error.stack;
+      const timestamp = 1234567890;
+
+      writer.writeError(error, 'op-111', 'init', timestamp);
+
+      const call = mockController.enqueue.mock.calls[0]![0];
+      expect(call).toContain('event: error');
+      expect(call).toContain('"error":"No stack"');
+      expect(call).not.toContain('"stack"');
+    });
+
+    it('should use "unknown" phase when phase is not provided', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+      const error = new Error('Test error');
+      const timestamp = 1234567890;
+
+      writer.writeError(error, 'op-222', undefined, timestamp);
+
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        expect.stringContaining('"phase":"unknown"'),
+      );
+    });
+
+    it('should handle string error', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+      const timestamp = 1234567890;
+
+      writer.writeError('Simple error string', 'op-333', 'validation', timestamp);
+
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        expect.stringContaining('"error":"Simple error string"'),
+      );
+    });
+
+    it('should use Date.now() when timestamp is not provided', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+      const error = new Error('Test');
+
+      writer.writeError(error, 'op-444');
+
+      const call = mockController.enqueue.mock.calls[0]![0];
+      expect(call).toContain('event: error');
+      expect(call).toMatch(/"timestamp":\d+/);
+    });
+  });
+
+  describe('writeEvent', () => {
+    it('should write custom event', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+
+      writer.writeEvent({
+        data: { custom: 'data' },
+        event: 'custom-event',
+        id: 'custom-123',
+      });
+
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        'id: custom-123\nevent: custom-event\ndata: {"custom":"data"}\n\n',
+      );
+    });
+
+    it('should write event with retry', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+
+      writer.writeEvent({
+        data: 'test',
+        retry: 10000,
+      });
+
+      expect(mockController.enqueue).toHaveBeenCalledWith('retry: 10000\ndata: test\n\n');
+    });
+  });
+
+  describe('writeHeartbeat', () => {
+    it('should write heartbeat event with timestamp', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+      const timestamp = 1234567890;
+
+      writer.writeHeartbeat(timestamp);
+
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        'id: heartbeat_1234567890\nevent: heartbeat\ndata: {"timestamp":1234567890,"type":"heartbeat"}\n\n',
+      );
+    });
+
+    it('should use Date.now() when timestamp is not provided', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+
+      writer.writeHeartbeat();
+
+      const call = mockController.enqueue.mock.calls[0]![0];
+      expect(call).toContain('event: heartbeat');
+      expect(call).toMatch(/"timestamp":\d+/);
+      expect(call).toMatch(/id: heartbeat_\d+/);
+    });
+  });
+
+  describe('writeStreamEvent', () => {
+    it('should write stream event with custom data', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+
+      writer.writeStreamEvent({ type: 'stream_chunk', content: 'hello' }, 'event-555');
+
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        'id: event-555\nevent: stream_chunk\ndata: {"type":"stream_chunk","content":"hello"}\n\n',
+      );
+    });
+
+    it('should use "stream" as default event type when type is not in data', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+
+      writer.writeStreamEvent({ content: 'message' }, 'event-666');
+
+      expect(mockController.enqueue).toHaveBeenCalledWith(
+        'id: event-666\nevent: stream\ndata: {"content":"message"}\n\n',
+      );
+    });
+
+    it('should generate event ID when not provided', () => {
+      const mockController = { enqueue: vi.fn() };
+      const writer = createSSEWriter(mockController as any);
+
+      writer.writeStreamEvent({ type: 'stream_end' });
+
+      const call = mockController.enqueue.mock.calls[0]![0];
+      expect(call).toContain('event: stream_end');
+      expect(call).toMatch(/id: event_\d+/);
+    });
+  });
+});
+
+describe('createSSEHeaders', () => {
+  it('should create headers with correct SSE configuration', () => {
+    const headers = createSSEHeaders();
+
+    expect(headers).toEqual({
+      'Access-Control-Allow-Headers': 'Cache-Control, Last-Event-ID',
+      'Access-Control-Allow-Methods': 'GET',
+      'Access-Control-Allow-Origin': '*',
+      'Cache-Control': 'no-cache, no-transform',
+      'Connection': 'keep-alive',
+      'Content-Type': 'text/event-stream',
+      'X-Accel-Buffering': 'no',
+    });
+  });
+
+  it('should include CORS headers', () => {
+    const headers = createSSEHeaders() as Record<string, string>;
+
+    expect(headers['Access-Control-Allow-Origin']).toBe('*');
+    expect(headers['Access-Control-Allow-Methods']).toBe('GET');
+    expect(headers['Access-Control-Allow-Headers']).toBe('Cache-Control, Last-Event-ID');
+  });
+
+  it('should include cache control headers', () => {
+    const headers = createSSEHeaders() as Record<string, string>;
+
+    expect(headers['Cache-Control']).toBe('no-cache, no-transform');
+  });
+
+  it('should include SSE-specific headers', () => {
+    const headers = createSSEHeaders() as Record<string, string>;
+
+    expect(headers['Content-Type']).toBe('text/event-stream');
+    expect(headers['Connection']).toBe('keep-alive');
+    expect(headers['X-Accel-Buffering']).toBe('no');
+  });
+});

package/src/app/[variants]/(main)/home/_layout/Body/Agent/List/AgentGroupItem/Editing.tsx

@@ -10,7 +10,7 @@ interface EditingProps {
 }
 
 const Editing = memo<EditingProps>(({ id, title, toggleEditing }) => {
-  const editing = useHomeStore((s) => s.agentRenamingId === id);
+  const editing = useHomeStore((s) => s.groupRenamingId === id);
 
   const [newTitle, setNewTitle] = useState(title);
 
@@ -19,17 +19,10 @@ const Editing = memo<EditingProps>(({ id, title, toggleEditing }) => {
 
     if (hasChanges) {
       try {
-        // Set loading state
-        useHomeStore.getState().setAgentUpdatingId(id);
-
-        // TODO: Add group title update logic here
-        // await updateGroupTitle(id, newTitle);
-
-        // Refresh agent list to update sidebar display
-        await useHomeStore.getState().refreshAgentList();
+        useHomeStore.getState().setGroupUpdatingId(id);
+        await useHomeStore.getState().renameAgentGroup(id, newTitle);
       } finally {
-        // Clear loading state
-        useHomeStore.getState().setAgentUpdatingId(null);
+        useHomeStore.getState().setGroupUpdatingId(null);
       }
     }
     toggleEditing(false);

package/src/app/[variants]/(main)/home/_layout/Body/Agent/List/AgentGroupItem/index.tsx

@@ -30,8 +30,8 @@ const GroupItem = memo<GroupItemProps>(({ item, style, className }) => {
 
   // Get UI state from homeStore (editing, updating)
   const [editing, isUpdating] = useHomeStore((s) => [
-    s.agentRenamingId === id,
-    s.agentUpdatingId === id,
+    s.groupRenamingId === id,
+    s.groupUpdatingId === id,
   ]);
 
   // Get display title with fallback
@@ -63,7 +63,7 @@ const GroupItem = memo<GroupItemProps>(({ item, style, className }) => {
 
   const toggleEditing = useCallback(
     (visible?: boolean) => {
-      useHomeStore.getState().setAgentRenamingId(visible ? id : null);
+      useHomeStore.getState().setGroupRenamingId(visible ? id : null);
     },
     [id],
   );