@lobehub/lobehub 2.0.0-next.286 → 2.0.0-next.288

package/src/store/chat/agents/GroupOrchestration/createGroupOrchestrationExecutors.ts

@@ -190,12 +190,13 @@ export const createGroupOrchestrationExecutors = (
 
       // If instruction is provided, inject it as a virtual User Message
       // This virtual message is not persisted to database, only used for model context
+      // Mark with <speaker> tag so the agent knows this instruction is from the Supervisor
       const now = Date.now();
       const messagesWithInstruction: UIChatMessage[] = agentInstruction
         ? [
             ...messages,
             {
-              content: agentInstruction,
+              content: `<speaker name="Supervisor" />\n${agentInstruction}`,
               createdAt: now,
               id: `virtual_speak_instruction_${now}`,
               role: 'user',
@@ -266,12 +267,13 @@ export const createGroupOrchestrationExecutors = (
 
       // If instruction is provided, inject it as a virtual User Message
       // This virtual message is not persisted to database, only used for model context
+      // Mark with <speaker> tag so the agent knows this instruction is from the Supervisor
       const now = Date.now();
       const messagesWithInstruction: UIChatMessage[] = agentInstruction
         ? [
             ...messages,
             {
-              content: agentInstruction,
+              content: `<speaker name="Supervisor" />\n${agentInstruction}`,
               createdAt: now,
               id: `virtual_broadcast_instruction_${now}`,
               role: 'user',

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

@@ -197,6 +197,8 @@ export const conversationLifecycle: StateCreator<
         // if there is topicId，then add topicId to message
         topicId: operationContext.topicId ?? undefined,
         threadId: operationContext.threadId ?? undefined,
+        // Pass isSupervisor metadata for group orchestration (consistent with server)
+        metadata: operationContext.isSupervisor ? { isSupervisor: true } : undefined,
       },
       { operationId, tempMessageId: tempAssistantId },
     );

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

@@ -592,7 +592,7 @@ export const streamingExecutor: StateCreator<
     // resolveAgentConfig handles:
     // - Builtin agent runtime config merging
     // - max_tokens/reasoning_effort based on chatConfig settings
-    const { agentConfig: agentConfigData, chatConfig } = resolveAgentConfig({
+    const { agentConfig: agentConfigData } = resolveAgentConfig({
       agentId: effectiveAgentId || '',
       scope: context.scope, // Pass scope from context parameter (available at line 883)
     });
@@ -863,22 +863,5 @@ export const streamingExecutor: StateCreator<
         console.error('Desktop notification error:', error);
       }
     }
-
-    // Summary history if context messages is larger than historyCount
-    const historyCount = chatConfig.historyCount ?? 0;
-
-    if (
-      chatConfig.enableHistoryCount &&
-      chatConfig.enableCompressHistory &&
-      messages.length > historyCount
-    ) {
-      // after generation: [u1,a1,u2,a2,u3,a3]
-      // but the `messages` is still: [u1,a1,u2,a2,u3]
-      // So if historyCount=2, we need to summary [u1,a1,u2,a2]
-      // because user find UI is [u1,a1,u2,a2 | u3,a3]
-      const historyMessages = messages.slice(0, -historyCount + 1);
-
-      await get().internal_summaryHistory(historyMessages);
-    }
   },
 });

package/src/store/chat/slices/message/selectors/displayMessage.test.ts

@@ -323,6 +323,30 @@ describe('displayMessageSelectors', () => {
       const result = displayMessageSelectors.currentDisplayChatKey(state as ChatStore);
       expect(result).toBe(messageMapKey({ agentId: '', topicId: undefined }));
     });
+
+    it('should generate correct key with activeGroupId for group conversations', () => {
+      const state: Partial<ChatStore> = {
+        activeAgentId: 'testId',
+        activeGroupId: 'groupId',
+        activeTopicId: undefined,
+      };
+      const result = displayMessageSelectors.currentDisplayChatKey(state as ChatStore);
+      expect(result).toBe(
+        messageMapKey({ agentId: 'testId', groupId: 'groupId', topicId: undefined }),
+      );
+    });
+
+    it('should generate correct key with activeGroupId and activeTopicId', () => {
+      const state: Partial<ChatStore> = {
+        activeAgentId: 'testId',
+        activeGroupId: 'groupId',
+        activeTopicId: 'topicId',
+      };
+      const result = displayMessageSelectors.currentDisplayChatKey(state as ChatStore);
+      expect(result).toBe(
+        messageMapKey({ agentId: 'testId', groupId: 'groupId', topicId: 'topicId' }),
+      );
+    });
   });
 
   describe('activeDisplayMessages with group chat messages', () => {

package/src/store/chat/slices/message/selectors/displayMessage.ts

@@ -24,9 +24,14 @@ import { messageMapKey } from '../../../utils/messageMapKey';
 
 /**
  * Get the current chat key for accessing messagesMap
+ * For group conversations, uses groupId to generate the correct key
  */
 export const currentDisplayChatKey = (s: ChatStoreState) =>
-  messageMapKey({ agentId: s.activeAgentId, topicId: s.activeTopicId });
+  messageMapKey({
+    agentId: s.activeAgentId,
+    groupId: s.activeGroupId,
+    topicId: s.activeTopicId,
+  });
 
 /**
  * Get display messages by key

package/src/store/chat/slices/topic/action.test.ts

@@ -462,7 +462,7 @@ describe('topic action', () => {
       });
     });
 
-    it('should NOT clear new key data when switching with undefined (backward compatibility)', async () => {
+    it('should clear new key data when switching with undefined (same as null)', async () => {
       const { result } = renderHook(() => useChatStore());
       const activeAgentId = 'test-agent-id';
 
@@ -475,13 +475,19 @@ describe('topic action', () => {
 
       const replaceMessagesSpy = vi.spyOn(result.current, 'replaceMessages');
 
-      // Switch with undefined (should NOT clear because id !== null)
+      // Switch with undefined (should clear because id == null matches both null and undefined)
       await act(async () => {
         await result.current.switchTopic(undefined, { skipRefreshMessage: true });
       });
 
-      // replaceMessages should NOT be called when switching with undefined
-      expect(replaceMessagesSpy).not.toHaveBeenCalled();
+      // replaceMessages SHOULD be called when switching with undefined
+      expect(replaceMessagesSpy).toHaveBeenCalledWith([], {
+        context: expect.objectContaining({
+          agentId: activeAgentId,
+          topicId: null,
+        }),
+        action: expect.any(String),
+      });
     });
 
     it('should not clear new key data when switching to an existing topic', async () => {

package/src/store/chat/slices/topic/action.ts

@@ -532,10 +532,11 @@ export const chatTopic: StateCreator<
     const { activeAgentId, activeGroupId } = get();
 
     // Clear the _new key data in the following cases:
-    // 1. When id is explicitly null (switching to empty topic state)
+    // 1. When id is null or undefined (switching to empty topic state)
     // 2. When clearNewKey option is explicitly true
     // This prevents stale data from previous conversations showing up
-    const shouldClearNewKey = id === null || opts.clearNewKey;
+    // Note: Use == null to match both null and undefined
+    const shouldClearNewKey = !id || opts.clearNewKey;
 
     if (shouldClearNewKey && activeAgentId) {
       // Determine scope: use explicit scope from options, or infer from activeGroupId

package/src/store/electron/selectors/sync.ts

@@ -1,12 +1,28 @@
+import { OFFICIAL_URL } from '@lobechat/const';
+
 import { type ElectronState } from '../initialState';
 
 const isSyncActive = (s: ElectronState) => s.dataSyncConfig.active;
 
 const storageMode = (s: ElectronState) => s.dataSyncConfig.storageMode;
-const remoteServerUrl = (s: ElectronState) => s.dataSyncConfig.remoteServerUrl || '';
+
+/**
+ * Returns the effective remote server URL based on storage mode:
+ * - Cloud mode: returns OFFICIAL_URL
+ * - SelfHost mode: returns the configured remoteServerUrl
+ */
+const remoteServerUrl = (s: ElectronState) =>
+  s.dataSyncConfig.storageMode === 'cloud' ? OFFICIAL_URL : s.dataSyncConfig.remoteServerUrl || '';
+
+/**
+ * Returns the raw remoteServerUrl from config without transformation.
+ * Use this when you need the original configured value (e.g., for editing forms).
+ */
+const rawRemoteServerUrl = (s: ElectronState) => s.dataSyncConfig.remoteServerUrl || '';
 
 export const electronSyncSelectors = {
   isSyncActive,
+  rawRemoteServerUrl,
   remoteServerUrl,
   storageMode,
 };

package/packages/context-engine/src/processors/GroupMessageSender.ts

@@ -1,138 +0,0 @@
-import debug from 'debug';
-
-import { BaseProcessor } from '../base/BaseProcessor';
-import type { Message, PipelineContext, ProcessorOptions } from '../types';
-
-const log = debug('context-engine:processor:GroupMessageSenderProcessor');
-
-/**
- * Agent info for message sender identification
- */
-export interface AgentInfo {
-  name: string;
-  role: 'supervisor' | 'participant';
-}
-
-/**
- * Configuration for GroupMessageSenderProcessor
- */
-export interface GroupMessageSenderConfig {
-  /**
-   * Mapping from agentId to agent info
-   * Used to look up agent name and role for each message
-   */
-  agentMap: Record<string, AgentInfo>;
-}
-
-/**
- * Group Message Sender Processor
- *
- * Responsible for injecting sender identity information into assistant messages
- * in group chat scenarios. This helps the model understand which agent sent
- * each message in a multi-agent conversation.
- *
- * The processor appends a system context block at the end of each assistant
- * message that has an agentId, containing:
- * - Agent name
- * - Agent role (supervisor or agent)
- * - Agent ID (with instruction not to expose it in responses)
- *
- * @example
- * ```typescript
- * const processor = new GroupMessageSenderProcessor({
- *   agentMap: {
- *     'agt_xxx': { name: 'Weather Expert', role: 'agent' },
- *     'agt_yyy': { name: 'Supervisor', role: 'supervisor' },
- *   }
- * });
- * ```
- */
-export class GroupMessageSenderProcessor extends BaseProcessor {
-  readonly name = 'GroupMessageSenderProcessor';
-
-  constructor(
-    private config: GroupMessageSenderConfig,
-    options: ProcessorOptions = {},
-  ) {
-    super(options);
-  }
-
-  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
-    const clonedContext = this.cloneContext(context);
-
-    // Skip if no agentMap provided
-    if (!this.config.agentMap || Object.keys(this.config.agentMap).length === 0) {
-      log('No agentMap provided, skipping processing');
-      return this.markAsExecuted(clonedContext);
-    }
-
-    let processedCount = 0;
-
-    clonedContext.messages = clonedContext.messages.map((msg: Message) => {
-      // Only process assistant messages with agentId
-      if (msg.role === 'assistant' && msg.agentId) {
-        const agentInfo = this.config.agentMap[msg.agentId];
-
-        if (agentInfo) {
-          // Build the sender tag
-          const senderTag = this.buildSenderContext(msg.agentId, agentInfo);
-
-          // Prepend to message content (at the beginning)
-          if (typeof msg.content === 'string') {
-            processedCount++;
-            log(
-              `Injecting sender info for message from agent: ${agentInfo.name} (${agentInfo.role})`,
-            );
-
-            return {
-              ...msg,
-              content: senderTag + msg.content,
-            };
-          }
-          // Handle array content (multimodal messages)
-          else if (Array.isArray(msg.content)) {
-            const firstTextIndex = msg.content.findIndex((part: any) => part.type === 'text');
-
-            if (firstTextIndex !== -1) {
-              processedCount++;
-              log(
-                `Injecting sender info for multimodal message from agent: ${agentInfo.name} (${agentInfo.role})`,
-              );
-
-              const newContent = [...msg.content];
-              newContent[firstTextIndex] = {
-                ...newContent[firstTextIndex],
-                text: senderTag + newContent[firstTextIndex].text,
-              };
-
-              return {
-                ...msg,
-                content: newContent,
-              };
-            }
-          }
-        }
-      }
-
-      return msg;
-    });
-
-    // Update metadata
-    clonedContext.metadata.groupMessageSenderProcessed = processedCount;
-
-    log(`Group message sender processing completed: ${processedCount} messages processed`);
-
-    return this.markAsExecuted(clonedContext);
-  }
-
-  /**
-   * Build the sender tag to prepend to assistant messages.
-   *
-   * Uses a self-closing XML tag at the beginning:
-   * - Placed at start so model sees "who is speaking" before the content
-   * - Self-closing tag is less likely to be reproduced as it's not a "wrapper"
-   */
-  private buildSenderContext(_agentId: string, agentInfo: AgentInfo): string {
-    return `<speaker name="${agentInfo.name}" />\n`;
-  }
-}

package/packages/context-engine/src/processors/__tests__/GroupMessageSender.test.ts

@@ -1,274 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { PipelineContext } from '../../types';
-import { GroupMessageSenderProcessor } from '../GroupMessageSender';
-
-describe('GroupMessageSenderProcessor', () => {
-  const createContext = (messages: any[]): PipelineContext => ({
-    initialState: { messages: [] },
-    isAborted: false,
-    messages,
-    metadata: {},
-  });
-
-  describe('Basic Scenarios', () => {
-    it('should inject sender info into assistant message with agentId', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_weather: { name: 'Weather Expert', role: 'participant' },
-        },
-      });
-
-      const input: any[] = [
-        { role: 'user', content: 'What is the weather?' },
-        { role: 'assistant', content: 'The weather is sunny.', agentId: 'agt_weather' },
-      ];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      expect(result.messages).toHaveLength(2);
-
-      // User message should be unchanged
-      expect(result.messages[0].content).toBe('What is the weather?');
-
-      // Assistant message should have speaker tag prepended
-      const assistantContent = result.messages[1].content;
-      expect(assistantContent).toMatch(/^<speaker name="Weather Expert" \/>/);
-      expect(assistantContent).toContain('The weather is sunny.');
-
-      // Check metadata
-      expect(result.metadata.groupMessageSenderProcessed).toBe(1);
-    });
-
-    it('should inject sender info for supervisor role', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_supervisor: { name: 'Group Supervisor', role: 'supervisor' },
-        },
-      });
-
-      const input: any[] = [
-        { role: 'assistant', content: 'I will coordinate the agents.', agentId: 'agt_supervisor' },
-      ];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      const assistantContent = result.messages[0].content;
-      expect(assistantContent).toMatch(/^<speaker name="Group Supervisor" \/>/);
-    });
-
-    it('should not modify assistant message without agentId', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_weather: { name: 'Weather Expert', role: 'participant' },
-        },
-      });
-
-      const input: any[] = [{ role: 'assistant', content: 'Hello from assistant.' }];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      // Should be unchanged
-      expect(result.messages[0].content).toBe('Hello from assistant.');
-      expect(result.metadata.groupMessageSenderProcessed).toBe(0);
-    });
-
-    it('should not modify assistant message with unknown agentId', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_weather: { name: 'Weather Expert', role: 'participant' },
-        },
-      });
-
-      const input: any[] = [{ role: 'assistant', content: 'Hello.', agentId: 'agt_unknown' }];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      // Should be unchanged because agentId not in map
-      expect(result.messages[0].content).toBe('Hello.');
-      expect(result.metadata.groupMessageSenderProcessed).toBe(0);
-    });
-
-    it('should not modify user or tool messages', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_weather: { name: 'Weather Expert', role: 'participant' },
-        },
-      });
-
-      const input: any[] = [
-        { role: 'user', content: 'Hello', agentId: 'agt_weather' },
-        { role: 'tool', content: 'Tool result', agentId: 'agt_weather' },
-      ];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      expect(result.messages[0].content).toBe('Hello');
-      expect(result.messages[1].content).toBe('Tool result');
-      expect(result.metadata.groupMessageSenderProcessed).toBe(0);
-    });
-  });
-
-  describe('Multiple Messages', () => {
-    it('should process multiple assistant messages from different agents', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_weather: { name: 'Weather Expert', role: 'participant' },
-          agt_news: { name: 'News Reporter', role: 'participant' },
-          agt_supervisor: { name: 'Supervisor', role: 'supervisor' },
-        },
-      });
-
-      const input: any[] = [
-        { role: 'user', content: 'Give me updates' },
-        { role: 'assistant', content: 'Weather is sunny.', agentId: 'agt_weather' },
-        { role: 'assistant', content: 'Top news today.', agentId: 'agt_news' },
-        { role: 'assistant', content: 'Summary complete.', agentId: 'agt_supervisor' },
-      ];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      expect(result.messages).toHaveLength(4);
-
-      // Check each assistant message has correct speaker tag prepended
-      expect(result.messages[1].content).toMatch(/^<speaker name="Weather Expert" \/>/);
-      expect(result.messages[2].content).toMatch(/^<speaker name="News Reporter" \/>/);
-      expect(result.messages[3].content).toMatch(/^<speaker name="Supervisor" \/>/);
-
-      expect(result.metadata.groupMessageSenderProcessed).toBe(3);
-    });
-  });
-
-  describe('Multimodal Messages', () => {
-    it('should handle array content (multimodal messages)', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_weather: { name: 'Weather Expert', role: 'participant' },
-        },
-      });
-
-      const input: any[] = [
-        {
-          role: 'assistant',
-          content: [
-            { type: 'text', text: 'Here is the weather chart.' },
-            { type: 'image_url', image_url: { url: 'https://example.com/chart.png' } },
-          ],
-          agentId: 'agt_weather',
-        },
-      ];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      const content = result.messages[0].content as any[];
-      expect(Array.isArray(content)).toBe(true);
-
-      // The first text part should have speaker tag prepended
-      const textPart = content.find((p: any) => p.type === 'text');
-      expect(textPart.text).toMatch(/^<speaker name="Weather Expert" \/>/);
-      expect(textPart.text).toContain('Here is the weather chart.');
-
-      // Image part should be unchanged
-      const imagePart = content.find((p: any) => p.type === 'image_url');
-      expect(imagePart.image_url.url).toBe('https://example.com/chart.png');
-
-      expect(result.metadata.groupMessageSenderProcessed).toBe(1);
-    });
-
-    it('should append to the last text part in multimodal content', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_weather: { name: 'Weather Expert', role: 'participant' },
-        },
-      });
-
-      const input: any[] = [
-        {
-          role: 'assistant',
-          content: [
-            { type: 'text', text: 'First text.' },
-            { type: 'image_url', image_url: { url: 'https://example.com/img.png' } },
-            { type: 'text', text: 'Last text.' },
-          ],
-          agentId: 'agt_weather',
-        },
-      ];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      const content = result.messages[0].content;
-
-      // First text part should have speaker tag prepended
-      expect(content[0].text).toMatch(/^<speaker name="Weather Expert" \/>/);
-      expect(content[0].text).toContain('First text.');
-
-      // Last text should be unchanged
-      expect(content[2].text).toBe('Last text.');
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should skip processing with empty agentMap', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {},
-      });
-
-      const input: any[] = [{ role: 'assistant', content: 'Hello', agentId: 'agt_weather' }];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      expect(result.messages[0].content).toBe('Hello');
-    });
-
-    it('should handle empty messages array', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_weather: { name: 'Weather Expert', role: 'participant' },
-        },
-      });
-
-      const context = createContext([]);
-      const result = await processor.process(context);
-
-      expect(result.messages).toHaveLength(0);
-      expect(result.metadata.groupMessageSenderProcessed).toBe(0);
-    });
-
-    it('should preserve original message properties', async () => {
-      const processor = new GroupMessageSenderProcessor({
-        agentMap: {
-          agt_weather: { name: 'Weather Expert', role: 'participant' },
-        },
-      });
-
-      const input: any[] = [
-        {
-          role: 'assistant',
-          content: 'Weather info.',
-          agentId: 'agt_weather',
-          id: 'msg-123',
-          createdAt: '2025-01-01T00:00:00Z',
-          customField: 'custom value',
-        },
-      ];
-
-      const context = createContext(input);
-      const result = await processor.process(context);
-
-      const msg = result.messages[0];
-      expect(msg.id).toBe('msg-123');
-      expect(msg.createdAt).toBe('2025-01-01T00:00:00Z');
-      expect(msg.customField).toBe('custom value');
-      expect(msg.agentId).toBe('agt_weather');
-    });
-  });
-});

package/src/features/ElectronTitlebar/const.ts

@@ -1 +0,0 @@
-export const TITLE_BAR_HEIGHT = 30;