@lobehub/chat 1.94.17 → 1.96.0

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

@@ -0,0 +1,53 @@
+export interface GoogleSearchParameters {
+  c2coff?: number;
+  cx: string;
+  dateRestrict?: string;
+  exactTerms?: string;
+  excludeTerms?: string;
+  fileType?: string;
+  filter?: string;
+  gl?: string;
+  highRange?: string;
+  hl?: string;
+  hq?: string;
+  imgColorType?: string;
+  imgDominantColor?: string;
+  imgSize?: string;
+  imgType?: string;
+  key: string;
+  linkSite?: string;
+  lowRange?: string;
+  lr?: string;
+  num?: number;
+  orTerms?: string;
+  q: string;
+  rights?: string;
+  safe?: string;
+  searchType?: string;
+  siteSearch?: string;
+  siteSearchFilter?: string;
+  sort?: string;
+  start?: string;
+}
+
+interface GoogleItems {
+  displayLink?: string;
+  formattedUrl?: string;
+  htmlFormattedUrl?: string;
+  htmlSnippet?: string;
+  htmlTitle?: string;
+  kind?: string;
+  link: string;
+  pagemap?: any;
+  snippet: string;
+  title: string;
+}
+
+export interface GoogleResponse {
+  context?: any;
+  items: GoogleItems[];
+  kind?: string;
+  queries?: any;
+  searchInformation?: any;
+  url?: any;
+}

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

@@ -1,7 +1,11 @@
+import { AnspireImpl } from './anspire';
 import { BochaImpl } from './bocha';
+import { BraveImpl } from './brave';
 import { ExaImpl } from './exa';
 import { FirecrawlImpl } from './firecrawl';
+import { GoogleImpl } from './google';
 import { JinaImpl } from './jina';
+import { KagiImpl } from './kagi';
 import { Search1APIImpl } from './search1api';
 import { SearXNGImpl } from './searxng';
 import { TavilyImpl } from './tavily';
@@ -12,10 +16,14 @@ import { SearchServiceImpl } from './type';
  * Available search service implementations
  */
 export enum SearchImplType {
+  Anspire = 'anspire',
   Bocha = 'bocha',
+  Brave = 'brave',
   Exa = 'exa',
   Firecrawl = 'firecrawl',
+  Google = 'google',
   Jina = 'jina',
+  Kagi = 'kagi',
   SearXNG = 'searxng',
   Search1API = 'search1api',
   Tavily = 'tavily',
@@ -28,10 +36,18 @@ export const createSearchServiceImpl = (
   type: SearchImplType = SearchImplType.SearXNG,
 ): SearchServiceImpl => {
   switch (type) {
+    case SearchImplType.Anspire: {
+      return new AnspireImpl();
+    }
+
     case SearchImplType.Bocha: {
       return new BochaImpl();
     }
 
+    case SearchImplType.Brave: {
+      return new BraveImpl();
+    }
+
     case SearchImplType.Exa: {
       return new ExaImpl();
     }
@@ -40,10 +56,18 @@ export const createSearchServiceImpl = (
       return new FirecrawlImpl();
     }
 
+    case SearchImplType.Google: {
+      return new GoogleImpl();
+    }
+
     case SearchImplType.Jina: {
       return new JinaImpl();
     }
 
+    case SearchImplType.Kagi: {
+      return new KagiImpl();
+    }
+
     case SearchImplType.SearXNG: {
       return new SearXNGImpl();
     }

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

@@ -0,0 +1,111 @@
+import { TRPCError } from '@trpc/server';
+import debug from 'debug';
+import urlJoin from 'url-join';
+
+import { SearchParams, UniformSearchResponse, UniformSearchResult } from '@/types/tool/search';
+
+import { SearchServiceImpl } from '../type';
+import { KagiSearchParameters, KagiResponse } from './type';
+
+const log = debug('lobe-search:Kagi');
+
+/**
+ * Kagi implementation of the search service
+ * Primarily used for web crawling
+ */
+export class KagiImpl implements SearchServiceImpl {
+  private get apiKey(): string | undefined {
+    return process.env.KAGI_API_KEY;
+  }
+
+  private get baseUrl(): string {
+    // Assuming the base URL is consistent with the crawl endpoint
+    return 'https://kagi.com/api/v0';
+  }
+
+  async query(query: string, params: SearchParams = {}): Promise<UniformSearchResponse> {
+    log('Starting Kagi query with query: "%s", params: %o', query, params);
+    const endpoint = urlJoin(this.baseUrl, '/search');
+
+    const body: KagiSearchParameters = {
+      limit: 15,
+      q: query,
+    };
+
+    log('Constructed request body: %o', body);
+
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+      searchParams.append(key, String(value));
+    }
+
+    let response: Response;
+    const startAt = Date.now();
+    let costTime = 0;
+    try {
+      log('Sending request to endpoint: %s', endpoint);
+      response = await fetch(`${endpoint}?${searchParams.toString()}`, {
+        headers: {
+          'Authorization': this.apiKey ? `Bot ${this.apiKey}` : '',
+        },
+        method: 'GET',
+      });
+      log('Received response with status: %d', response.status);
+      costTime = Date.now() - startAt;
+    } catch (error) {
+      log.extend('error')('Kagi fetch error: %o', error);
+      throw new TRPCError({
+        cause: error,
+        code: 'SERVICE_UNAVAILABLE',
+        message: 'Failed to connect to Kagi.',
+      });
+    }
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      log.extend('error')(
+        `Kagi request failed with status ${response.status}: %s`,
+        errorBody.length > 200 ? `${errorBody.slice(0, 200)}...` : errorBody,
+      );
+      throw new TRPCError({
+        cause: errorBody,
+        code: 'SERVICE_UNAVAILABLE',
+        message: `Kagi request failed: ${response.statusText}`,
+      });
+    }
+
+    try {
+      const kagiResponse = (await response.json()) as KagiResponse;
+
+      log('Parsed Kagi response: %o', kagiResponse);
+
+      const mappedResults = (kagiResponse.data || []).map(
+        (result): UniformSearchResult => ({
+          category: 'general', // Default category
+          content: result.snippet || '', // Prioritize content
+          engines: ['kagi'], // Use 'kagi' as the engine name
+          parsedUrl: result.url ? new URL(result.url).hostname : '', // Basic URL parsing
+          score: 1, // Default score to 1
+          title: result.title || '',
+          url: result.url,
+        }),
+      );
+
+      log('Mapped %d results to SearchResult format', mappedResults.length);
+
+      return {
+        costTime,
+        query: query,
+        resultNumbers: mappedResults.length,
+        results: mappedResults,
+      };
+    } catch (error) {
+      log.extend('error')('Error parsing Kagi response: %o', error);
+      throw new TRPCError({
+        cause: error,
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Failed to parse Kagi response.',
+      });
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+export interface KagiSearchParameters {
+  limit?: number;
+  q: string;
+}
+
+interface KagiThumbnail {
+  height?: number | null;
+  url: string;
+  width?: number | null;
+}
+
+interface KagiData {
+  published?: number;
+  snippet?: string;
+  t: number;
+  thumbnail?: KagiThumbnail;
+  title: string;
+  url: string;
+}
+
+export interface KagiResponse {
+  data: KagiData[];
+  meta?: any;
+}

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

@@ -1,6 +1,7 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
 // Disable the auto sort key eslint rule to make the code more logic and readable
 import { produce } from 'immer';
+import { template } from 'lodash-es';
 import { StateCreator } from 'zustand/vanilla';
 
 import { LOADING_FLAT, MESSAGE_CANCEL_FLAT } from '@/const/message';
@@ -507,6 +508,10 @@ export const generateAIChat: StateCreator<
     const agentConfig = agentSelectors.currentAgentConfig(getAgentStoreState());
     const chatConfig = agentChatConfigSelectors.currentChatConfig(getAgentStoreState());
 
+    const compiler = template(chatConfig.inputTemplate, {
+      interpolate: /{{\s*(text)\s*}}/g
+    });
+
     // ================================== //
     //   messages uniformly preprocess    //
     // ================================== //
@@ -521,17 +526,34 @@ export const generateAIChat: StateCreator<
       historyCount,
     });
 
-    // 2. add systemRole
+    // 2. replace inputMessage template
+    preprocessMsgs = !chatConfig.inputTemplate
+    ? preprocessMsgs
+    : preprocessMsgs.map((m) => {
+        if (m.role === 'user') {
+          try {
+            return { ...m, content: compiler({ text: m.content }) };
+          } catch (error) {
+            console.error(error);
+
+            return m;
+          }
+        }
+
+        return m;
+      });
+
+    // 3. add systemRole
     if (agentConfig.systemRole) {
       preprocessMsgs.unshift({ content: agentConfig.systemRole, role: 'system' } as ChatMessage);
     }
 
-    // 3. handle max_tokens
+    // 4. handle max_tokens
     agentConfig.params.max_tokens = chatConfig.enableMaxTokens
       ? agentConfig.params.max_tokens
       : undefined;
 
-    // 4. handle reasoning_effort
+    // 5. handle reasoning_effort
     agentConfig.params.reasoning_effort = chatConfig.enableReasoningEffort
       ? agentConfig.params.reasoning_effort
       : undefined;

package/src/types/user/settings/keyVaults.ts

@@ -80,6 +80,7 @@ export interface UserKeyVaults extends SearchEngineKeyVaults {
   tencentcloud?: OpenAICompatibleKeyVault;
   togetherai?: OpenAICompatibleKeyVault;
   upstage?: OpenAICompatibleKeyVault;
+  v0?: OpenAICompatibleKeyVault;
   vertexai?: OpenAICompatibleKeyVault;
   vllm?: OpenAICompatibleKeyVault;
   volcengine?: OpenAICompatibleKeyVault;

package/src/utils/client/parserPlaceholder.test.ts

@@ -21,18 +21,6 @@ vi.mock('@/store/user/selectors', () => ({
   },
 }));
 
-vi.mock('@/store/agent/store', () => ({
-  getAgentStoreState: () => ({}),
-}));
-
-vi.mock('@/store/agent/selectors', () => ({
-  agentChatConfigSelectors: {
-    currentChatConfig: () => ({
-      inputTemplate: 'Hello {{username}}!',
-    }),
-  },
-}));
-
 describe('parsePlaceholderVariablesMessages', () => {
   beforeEach(() => {
     // Mock Date for consistent testing
@@ -238,15 +226,6 @@ describe('parsePlaceholderVariablesMessages', () => {
       // Unknown variables should remain unchanged
       expect(result[0].content).toBe('Hello {{unknown_variable}}!');
     });
-
-    it('should handle nested variables (input_template)', () => {
-      const messages = [{ id: '1', content: 'Template: {{input_template}}' }];
-
-      const result = parsePlaceholderVariablesMessages(messages);
-
-      // Should resolve nested variables in input_template
-      expect(result[0].content).toBe('Template: Hello testuser!');
-    });
   });
 
   describe('specific variable types', () => {

package/src/utils/client/parserPlaceholder.ts

@@ -5,9 +5,6 @@ import { uuid } from '@/utils/uuid';
 import { useUserStore } from '@/store/user';
 import { userProfileSelectors } from '@/store/user/selectors';
 
-import { getAgentStoreState } from '@/store/agent/store';
-import { agentChatConfigSelectors } from '@/store/agent/selectors';
-
 const placeholderVariablesRegex = /{{(.*?)}}/g;
 
 /* eslint-disable sort-keys-fix/sort-keys-fix */
@@ -108,16 +105,6 @@ export const VARIABLE_GENERATORS = {
   language: () => typeof navigator !== 'undefined' ? navigator.language : '',
   platform: () => typeof navigator !== 'undefined' ? navigator.platform : '',
   user_agent: () => typeof navigator !== 'undefined' ? navigator.userAgent : '',
-
-  /**
-  * LobeChat 模板变量
-  *
-  * | Value | Example |
-  * |-------|---------|
-  * | `{{input_template}}` | Some contents |
-  *
-  */
-  input_template: () => agentChatConfigSelectors.currentChatConfig(getAgentStoreState()).inputTemplate || '',
 } as Record<string, () => string>;
 
 /**
@@ -133,13 +120,13 @@ const extractPlaceholderVariables = (text: string): string[] => {
 /**
  * 将模板变量替换为实际值，并支持递归解析嵌套变量
  * @param text - 含变量的原始文本
- * @param depth - 递归深度，默认 1，设置更高可支持 {{input_template}} 中的 {{date}} 等
+ * @param depth - 递归深度，默认 1，设置更高可支持 {{text}} 中的 {{date}} 等
  * @returns 替换后的文本
  */
 export const parsePlaceholderVariables = (text: string, depth = 2): string => {
   let result = text;
 
-  // 递归解析，用于处理如 {{input_template}} 存在额外预设变量
+  // 递归解析，用于处理如 {{text}} 存在额外预设变量
   for (let i = 0; i < depth; i++) {
     try {
       const variables = Object.fromEntries(