@lobehub/lobehub 2.0.0-next.1 → 2.0.0-next.11

package/src/server/services/search/impls/firecrawl/index.ts

@@ -26,7 +26,7 @@ export class FirecrawlImpl implements SearchServiceImpl {
 
   private get baseUrl(): string {
     // Assuming the base URL is consistent with the crawl endpoint
-    return process.env.FIRECRAWL_URL || 'https://api.firecrawl.dev/v1';
+    return process.env.FIRECRAWL_URL || 'https://api.firecrawl.dev/v2';
   }
 
   async query(query: string, params: SearchParams = {}): Promise<UniformSearchResponse> {
@@ -34,13 +34,14 @@ export class FirecrawlImpl implements SearchServiceImpl {
     const endpoint = urlJoin(this.baseUrl, '/search');
 
     const defaultQueryParams: FirecrawlSearchParameters = {
-      limit: 15,
+      limit: 20,
       query,
       /*
       scrapeOptions: {
         formats: ["markdown"]
       },
       */
+      sources: [{ type: 'web' }, { type: 'news' }],
     };
 
     let body: FirecrawlSearchParameters = {
@@ -95,25 +96,64 @@ export class FirecrawlImpl implements SearchServiceImpl {
 
       log('Parsed Firecrawl response: %o', firecrawlResponse);
 
-      const mappedResults = (firecrawlResponse.data || []).map(
+      // V2 API returns data as object with web/images/news arrays
+      const webResults = firecrawlResponse.data.web || [];
+      const imageResults = firecrawlResponse.data.images || [];
+      const newsResults = firecrawlResponse.data.news || [];
+
+      // Map web results
+      const mappedWebResults = webResults.map(
+        (result): UniformSearchResult => ({
+          category: 'general',
+          content: result.description || result.markdown || '',
+          engines: ['firecrawl'],
+          parsedUrl: result.url ? new URL(result.url).hostname : '',
+          score: 1,
+          title: result.title || '',
+          url: result.url,
+        }),
+      );
+
+      // Map news results
+      const mappedNewsResults = newsResults.map(
         (result): UniformSearchResult => ({
-          category: 'general', // Default category
-          content: result.description || '', // Prioritize content, fallback to snippet
-          engines: ['firecrawl'], // Use 'firecrawl' as the engine name
-          parsedUrl: result.url ? new URL(result.url).hostname : '', // Basic URL parsing
-          score: 1, // Default score to 1
+          category: 'news',
+          content: result.snippet || result.markdown || '',
+          engines: ['firecrawl'],
+          parsedUrl: result.url ? new URL(result.url).hostname : '',
+          score: 1,
           title: result.title || '',
           url: result.url,
         }),
       );
 
-      log('Mapped %d results to SearchResult format', mappedResults.length);
+      // Map image results
+      const mappedImageResults = imageResults.map(
+        (result): UniformSearchResult => ({
+          category: 'images',
+          content: result.title || '',
+          engines: ['firecrawl'],
+          parsedUrl: result.url ? new URL(result.url).hostname : '',
+          score: 1,
+          title: result.title || '',
+          url: result.imageUrl, // Use imageUrl for images
+        }),
+      );
+
+      // Combine all results
+      const allResults = [...mappedWebResults, ...mappedNewsResults, ...mappedImageResults];
+
+      log('Mapped %d results to SearchResult format', allResults.length);
+
+      if (firecrawlResponse.warning) {
+        log.extend('warn')('Firecrawl warning: %s', firecrawlResponse.warning);
+      }
 
       return {
         costTime,
         query: query,
-        resultNumbers: mappedResults.length,
-        results: mappedResults,
+        resultNumbers: allResults.length,
+        results: allResults,
       };
     } catch (error) {
       log.extend('error')('Error parsing Firecrawl response: %o', error);

package/src/server/services/search/impls/firecrawl/type.ts

@@ -1,35 +1,86 @@
+// V2 API Types
 interface FirecrawlScrapeOptions {
-  formats: string[];
+  blockAds?: boolean;
+  formats?: string[];
+  maxAge?: number;
+  onlyMainContent?: boolean;
+  removeBase64Images?: boolean;
 }
 
+type FirecrawlSource =
+  | { location?: string; tbs?: string; type: 'web' }
+  | { type: 'images' }
+  | { type: 'news' };
+
+type FirecrawlCategory = { type: 'github' } | { type: 'research' } | { type: 'pdf' };
+
 export interface FirecrawlSearchParameters {
+  categories?: FirecrawlCategory[];
   country?: string;
-  lang?: string;
+  ignoreInvalidURLs?: boolean;
   limit?: number;
+  location?: string;
   query: string;
   scrapeOptions?: FirecrawlScrapeOptions;
+  sources?: FirecrawlSource[];
   tbs?: string;
   timeout?: number;
 }
 
 interface FirecrawlMetadata {
   description?: string;
+  error?: string | null;
   sourceURL?: string;
   statusCode?: number;
+  title?: string;
+}
+
+// Web search result
+interface FirecrawlWebResult {
+  description: string;
+  html?: string | null;
+  links?: string[];
+  markdown?: string | null;
+  metadata?: FirecrawlMetadata;
+  rawHtml?: string | null;
+  screenshot?: string | null;
   title: string;
+  url: string;
 }
 
-interface FirecrawlData {
-  description?: string;
-  html?: string;
+// Image search result
+interface FirecrawlImageResult {
+  imageHeight: number;
+  imageUrl: string;
+  imageWidth: number;
+  position: number;
+  title: string;
+  url: string;
+}
+
+// News search result
+interface FirecrawlNewsResult {
+  date: string;
+  html?: string | null;
+  imageUrl?: string;
   links?: string[];
-  markdown?: string;
+  markdown?: string | null;
   metadata?: FirecrawlMetadata;
-  title?: string;
+  position: number;
+  rawHtml?: string | null;
+  screenshot?: string | null;
+  snippet: string;
+  title: string;
   url: string;
 }
 
+// V2 Response structure
 export interface FirecrawlResponse {
-  data: FirecrawlData[];
-  success?: boolean;
+  data: {
+    images?: FirecrawlImageResult[];
+    news?: FirecrawlNewsResult[];
+    web?: FirecrawlWebResult[];
+  };
+  success: boolean;
+  warning?: string | null;
 }

package/src/services/chat/chat.test.ts

@@ -8,18 +8,12 @@ import { type Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vite
 
 import { DEFAULT_USER_AVATAR } from '@/const/meta';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
-import * as isCanUseFCModule from '@/helpers/isCanUseFC';
 import * as toolEngineeringModule from '@/helpers/toolEngineering';
-import { agentChatConfigSelectors, agentSelectors } from '@/store/agent/selectors';
+import { agentChatConfigSelectors } from '@/store/agent/selectors';
 import { aiModelSelectors } from '@/store/aiInfra';
 import { useToolStore } from '@/store/tool';
-import { toolSelectors } from '@/store/tool/selectors';
-import { modelProviderSelectors } from '@/store/user/selectors';
-import { DalleManifest } from '@/tools/dalle';
 import { WebBrowsingManifest } from '@/tools/web-browsing';
 
-import { API_ENDPOINTS } from '../_url';
-import * as helpers from './helper';
 import { chatService } from './index';
 
 // Mocking external dependencies
@@ -831,39 +825,6 @@ describe('ChatService', () => {
           undefined,
         );
       });
-
-      it('work with dalle3', async () => {
-        const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
-        const messages = [
-          {
-            role: 'user',
-            content: 'https://vercel.com/ 请分析 chatGPT 关键词\n\n',
-            sessionId: 'inbox',
-            createdAt: 1702723964330,
-            id: 'vyQvEw6V',
-            updatedAt: 1702723964330,
-            extra: {},
-            meta: {
-              avatar: DEFAULT_USER_AVATAR,
-            },
-          },
-        ] as UIChatMessage[];
-
-        await chatService.createAssistantMessage({
-          messages,
-          model: 'gpt-3.5-turbo-1106',
-          top_p: 1,
-          plugins: [DalleManifest.identifier],
-        });
-
-        // Assert that getChatCompletionSpy was called with the expected arguments
-        expect(getChatCompletionSpy).toHaveBeenCalled();
-
-        const calls = getChatCompletionSpy.mock.lastCall;
-        // Take a snapshot of the first call's first argument
-        expect(calls![0]).toMatchSnapshot();
-        expect(calls![1]).toBeUndefined();
-      });
     });
 
     describe('search functionality', () => {

package/src/services/chat/contextEngineering.test.ts

@@ -248,36 +248,6 @@ describe('contextEngineering', () => {
     ]);
   });
 
-  it('should inject INBOX_GUIDE_SYSTEM_ROLE for welcome questions in inbox session', async () => {
-    // Don't mock INBOX_GUIDE_SYSTEMROLE, use the real one
-    const messages: UIChatMessage[] = [
-      {
-        role: 'user',
-        content: 'Hello, this is my first question',
-        createdAt: Date.now(),
-        id: 'test-welcome',
-        meta: {},
-        updatedAt: Date.now(),
-      },
-    ];
-
-    const result = await contextEngineering({
-      messages,
-      model: 'gpt-4',
-      provider: 'openai',
-      isWelcomeQuestion: true,
-      sessionId: 'inbox',
-    });
-
-    // Should have system message with inbox guide content
-    const systemMessage = result.find((msg) => msg.role === 'system');
-    expect(systemMessage).toBeDefined();
-    // Check for characteristic content of the actual INBOX_GUIDE_SYSTEMROLE
-    expect(systemMessage!.content).toContain('LobeChat Support Assistant');
-    expect(systemMessage!.content).toContain('LobeHub');
-    expect(Object.keys(systemMessage!).length).toEqual(2);
-  });
-
   it('should inject historySummary into system message when provided', async () => {
     const historySummary = 'Previous conversation summary: User discussed AI topics.';
 

package/src/services/chat/contextEngineering.ts

@@ -1,9 +1,8 @@
-import { INBOX_GUIDE_SYSTEMROLE, INBOX_SESSION_ID, isDesktop, isServerMode } from '@lobechat/const';
+import { isDesktop, isServerMode } from '@lobechat/const';
 import {
   ContextEngine,
   HistorySummaryProvider,
   HistoryTruncateProcessor,
-  InboxGuideProvider,
   InputTemplateProcessor,
   MessageCleanupProcessor,
   MessageContentProcessor,
@@ -48,8 +47,6 @@ export const contextEngineering = async ({
   enableHistoryCount,
   historyCount,
   historySummary,
-  sessionId,
-  isWelcomeQuestion,
 }: ContextEngineeringContext): Promise<OpenAIChatMessage[]> => {
   const toolNameResolver = new ToolNameResolver();
 
@@ -63,14 +60,6 @@ export const contextEngineering = async ({
       // 2. System role injection (agent's system role)
       new SystemRoleInjector({ systemRole }),
 
-      // 3. Inbox guide system role injection
-      new InboxGuideProvider({
-        inboxGuideSystemRole: INBOX_GUIDE_SYSTEMROLE,
-        inboxSessionId: INBOX_SESSION_ID,
-        isWelcomeQuestion: isWelcomeQuestion,
-        sessionId: sessionId,
-      }),
-
       // 4. Tool system role injection
       new ToolSystemRoleProvider({
         getToolSystemRoles: (tools) => toolSelectors.enabledSystemRoles(tools)(getToolStoreState()),

package/src/services/chat/index.ts

@@ -66,7 +66,6 @@ interface FetchAITaskResultParams extends FetchSSEOptions {
 interface CreateAssistantMessageStream extends FetchSSEOptions {
   abortController?: AbortController;
   historySummary?: string;
-  isWelcomeQuestion?: boolean;
   params: GetChatCompletionPayload;
   trace?: TracePayload;
 }
@@ -113,9 +112,7 @@ class ChatService {
       enableHistoryCount: agentChatConfigSelectors.enableHistoryCount(agentStoreState),
       // include user messages
       historyCount: agentChatConfigSelectors.historyCount(agentStoreState) + 2,
-      historySummary: options?.historySummary,
       inputTemplate: chatConfig.inputTemplate,
-      isWelcomeQuestion: options?.isWelcomeQuestion,
       messages,
       model: payload.model,
       provider: payload.provider!,
@@ -217,12 +214,10 @@ class ChatService {
     onErrorHandle,
     onFinish,
     trace,
-    isWelcomeQuestion,
     historySummary,
   }: CreateAssistantMessageStream) => {
     await this.createAssistantMessage(params, {
       historySummary,
-      isWelcomeQuestion,
       onAbort,
       onErrorHandle,
       onFinish,
@@ -404,7 +399,7 @@ class ChatService {
     onLoadingChange?.(true);
 
     try {
-      const oaiMessages = await contextEngineering({
+      const llmMessages = await contextEngineering({
         messages: params.messages as any,
         model: params.model!,
         provider: params.provider!,
@@ -421,7 +416,7 @@ class ChatService {
       // remove plugins
       delete params.plugins;
       await this.getChatCompletion(
-        { ...params, messages: oaiMessages, tools },
+        { ...params, messages: llmMessages, tools },
         {
           onErrorHandle: (error) => {
             errorHandle(new Error(error.message), error);

package/src/services/chat/types.ts

@@ -1,9 +1,9 @@
 import { TracePayload } from '@lobechat/types';
+
 import { FetchSSEOptions } from '@/utils/fetch';
 
 export interface FetchOptions extends FetchSSEOptions {
   historySummary?: string;
-  isWelcomeQuestion?: boolean;
   signal?: AbortSignal | undefined;
   trace?: TracePayload;
 }

package/src/services/message/_deprecated.ts

@@ -102,7 +102,7 @@ export class ClientService implements IMessageService {
   }
 
   // @ts-ignore
-  async updateMessage(id: string, message: Partial<DB_Message>) {
+  async updateMessage(id: string, message: Partial<DB_Message>): Promise<any> {
     return MessageModel.update(id, message);
   }
 

package/src/services/message/client.ts

@@ -45,6 +45,7 @@ export class ClientService extends BaseClientService implements IMessageService
         topicId,
       },
       {
+        groupAssistantMessages: false,
         postProcessUrl: this.postProcessUrl,
       },
     );
@@ -60,6 +61,7 @@ export class ClientService extends BaseClientService implements IMessageService
         topicId,
       },
       {
+        groupAssistantMessages: false,
         postProcessUrl: this.postProcessUrl,
       },
     );
@@ -99,8 +101,12 @@ export class ClientService extends BaseClientService implements IMessageService
     return this.messageModel.update(id, { error });
   };
 
-  updateMessage: IMessageService['updateMessage'] = async (id, message) => {
-    return this.messageModel.update(id, message);
+  updateMessage: IMessageService['updateMessage'] = async (id, message, options) => {
+    return this.messageModel.update(id, message, {
+      postProcessUrl: this.postProcessUrl,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+    });
   };
 
   updateMessageTTS: IMessageService['updateMessageTTS'] = async (id, tts) => {

package/src/services/message/server.ts

@@ -81,8 +81,13 @@ export class ServerService implements IMessageService {
     return lambdaClient.message.updateMessagePlugin.mutate({ id, value: { arguments: args } });
   };
 
-  updateMessage: IMessageService['updateMessage'] = async (id, value) => {
-    return lambdaClient.message.update.mutate({ id, value });
+  updateMessage: IMessageService['updateMessage'] = async (id, value, options) => {
+    return lambdaClient.message.update.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      value,
+    });
   };
 
   updateMessageTranslate: IMessageService['updateMessageTranslate'] = async (id, translate) => {

package/src/services/message/type.ts

@@ -10,6 +10,7 @@ import {
   UIChatMessage,
   UpdateMessageParams,
   UpdateMessageRAGParams,
+  UpdateMessageResult,
 } from '@lobechat/types';
 import type { HeatmapsProps } from '@lobehub/charts';
 
@@ -37,7 +38,11 @@ export interface IMessageService {
   rankModels(): Promise<ModelRankItem[]>;
   getHeatmaps(): Promise<HeatmapsProps['data']>;
   updateMessageError(id: string, error: ChatMessageError): Promise<any>;
-  updateMessage(id: string, message: Partial<UpdateMessageParams>): Promise<any>;
+  updateMessage(
+    id: string,
+    message: Partial<UpdateMessageParams>,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult>;
   updateMessageTTS(id: string, tts: Partial<ChatTTS> | false): Promise<any>;
   updateMessageTranslate(id: string, translate: Partial<ChatTranslate> | false): Promise<any>;
   updateMessagePluginState(id: string, value: Record<string, any>): Promise<any>;

package/src/services/user/client.test.ts

@@ -26,7 +26,10 @@ beforeEach(async () => {
   await initializeDB();
   await clientDB.delete(users);
 
-  await clientDB.insert(users).values({ id: mockUser.uuid, avatar: 'avatar.png' });
+  await clientDB
+    .insert(users)
+    .values({ id: mockUser.uuid, avatar: 'avatar.png' })
+    .onConflictDoNothing();
   await clientDB
     .insert(userSettings)
     .values({ id: mockUser.uuid, general: { themeMode: 'light' } });

package/src/store/chat/helpers.test.ts

@@ -64,6 +64,105 @@ describe('chatHelpers', () => {
       const message = chatHelpers.getMessageById([], '1');
       expect(message).toBeUndefined();
     });
+
+    it('finds a block within a group message', () => {
+      const messagesWithGroup = [
+        { id: '1', content: 'Hello' },
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          children: [
+            { id: 'block1', content: 'First block' },
+            { id: 'block2', content: 'Second block' },
+          ],
+        },
+      ] as UIChatMessage[];
+
+      const block = chatHelpers.getMessageById(messagesWithGroup, 'block1');
+      expect(block).toBeDefined();
+      expect(block?.id).toBe('block1');
+      expect(block?.content).toBe('First block');
+    });
+
+    it('returns block with parentId set to group message id', () => {
+      const messagesWithGroup = [
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          children: [{ id: 'block1', content: 'Block content' }],
+        },
+      ] as UIChatMessage[];
+
+      const block = chatHelpers.getMessageById(messagesWithGroup, 'block1');
+      expect(block).toBeDefined();
+      expect(block?.parentId).toBe('group1');
+    });
+
+    it('searches across multiple group messages', () => {
+      const messagesWithGroups = [
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          children: [{ id: 'block1', content: 'First group block' }],
+        },
+        {
+          id: 'group2',
+          role: 'group',
+          content: '',
+          children: [{ id: 'block2', content: 'Second group block' }],
+        },
+      ] as UIChatMessage[];
+
+      const block = chatHelpers.getMessageById(messagesWithGroups, 'block2');
+      expect(block).toBeDefined();
+      expect(block?.id).toBe('block2');
+      expect(block?.parentId).toBe('group2');
+      expect(block?.content).toBe('Second group block');
+    });
+
+    it('prioritizes top-level message over block with same id', () => {
+      const messagesWithConflict = [
+        { id: 'duplicate', content: 'Top-level message', role: 'user' },
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          children: [{ id: 'duplicate', content: 'Block message' }],
+        },
+      ] as UIChatMessage[];
+
+      const message = chatHelpers.getMessageById(messagesWithConflict, 'duplicate');
+      expect(message).toBeDefined();
+      expect(message?.content).toBe('Top-level message');
+      expect(message?.role).toBe('user');
+      expect(message?.parentId).toBeUndefined();
+    });
+
+    it('returns undefined when block is not found in any group', () => {
+      const messagesWithGroup = [
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          children: [{ id: 'block1', content: 'Block content' }],
+        },
+      ] as UIChatMessage[];
+
+      const block = chatHelpers.getMessageById(messagesWithGroup, 'nonexistent');
+      expect(block).toBeUndefined();
+    });
+
+    it('handles group message without children', () => {
+      const messagesWithEmptyGroup = [
+        { id: 'group1', role: 'group', content: '' },
+      ] as UIChatMessage[];
+
+      const block = chatHelpers.getMessageById(messagesWithEmptyGroup, 'block1');
+      expect(block).toBeUndefined();
+    });
   });
 
   describe('getSlicedMessages', () => {

package/src/store/chat/helpers.ts

@@ -5,8 +5,27 @@ import { encodeAsync } from '@/utils/tokenizer';
 export const getMessagesTokenCount = async (messages: OpenAIChatMessage[]) =>
   encodeAsync(messages.map((m) => m.content).join(''));
 
-export const getMessageById = (messages: UIChatMessage[], id: string) =>
-  messages.find((m) => m.id === id);
+export const getMessageById = (
+  messages: UIChatMessage[],
+  id: string,
+): UIChatMessage | undefined => {
+  // First try to find in top-level messages
+  const directMatch = messages.find((m) => m.id === id);
+  if (directMatch) return directMatch;
+
+  // If not found, search in group message children (blocks)
+  for (const message of messages) {
+    if (message.role === 'group' && message.children) {
+      const blockMatch = message.children.find((block) => block.id === id);
+      if (blockMatch) {
+        // Return the block with parentId set to group message ID
+        return { ...blockMatch, parentId: message.id } as UIChatMessage;
+      }
+    }
+  }
+
+  return undefined;
+};
 
 const getSlicedMessages = (
   messages: UIChatMessage[],

package/src/store/chat/selectors.ts

@@ -1,6 +1,6 @@
 export { aiChatSelectors } from './slices/aiChat/selectors';
 export { chatToolSelectors } from './slices/builtinTool/selectors';
-export { chatSelectors } from './slices/message/selectors';
+export * from './slices/message/selectors';
 export * from './slices/portal/selectors';
 export { threadSelectors } from './slices/thread/selectors';
 export { topicSelectors } from './slices/topic/selectors';

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

@@ -29,7 +29,7 @@ import { useSessionStore } from '@/store/session';
 import { WebBrowsingManifest } from '@/tools/web-browsing';
 import { Action, setNamespace } from '@/utils/storeDebug';
 
-import { chatSelectors, topicSelectors } from '../../../selectors';
+import { chatSelectors, messageStateSelectors, topicSelectors } from '../../../selectors';
 
 const n = setNamespace('ai');
 
@@ -598,7 +598,6 @@ export const generateAIChat: StateCreator<
         topicId: get().activeTopicId,
         traceName: TraceNameMap.Conversation,
       },
-      isWelcomeQuestion: params?.isWelcomeQuestion,
       onErrorHandle: async (error) => {
         await messageService.updateMessageError(messageId, error);
         await refreshMessages();
@@ -707,7 +706,8 @@ export const generateAIChat: StateCreator<
             if (!duration) {
               duration = Date.now() - thinkingStartAt;
 
-              const isInChatReasoning = chatSelectors.isMessageInChatReasoning(messageId)(get());
+              const isInChatReasoning =
+                messageStateSelectors.isMessageInChatReasoning(messageId)(get());
               if (isInChatReasoning) {
                 internal_toggleChatReasoning(
                   false,

package/src/store/chat/slices/builtinTool/actions/index.ts

@@ -2,14 +2,12 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { ChatStore } from '@/store/chat/store';
 
-import { ChatDallEAction, dalleSlice } from './dalle';
 import { ChatCodeInterpreterAction, codeInterpreterSlice } from './interpreter';
 import { LocalFileAction, localSystemSlice } from './localSystem';
 import { SearchAction, searchSlice } from './search';
 
 export interface ChatBuiltinToolAction
-  extends ChatDallEAction,
-    SearchAction,
+  extends SearchAction,
     LocalFileAction,
     ChatCodeInterpreterAction {}
 
@@ -19,7 +17,6 @@ export const chatToolSlice: StateCreator<
   [],
   ChatBuiltinToolAction
 > = (...params) => ({
-  ...dalleSlice(...params),
   ...searchSlice(...params),
   ...localSystemSlice(...params),
   ...codeInterpreterSlice(...params),