@lobehub/lobehub 2.0.0-next.25 → 2.0.0-next.27

package/packages/database/migrations/meta/_journal.json

@@ -301,6 +301,13 @@
       "when": 1762232313711,
       "tag": "0042_improve_agent_index",
       "breakpoints": true
+    },
+    {
+      "idx": 43,
+      "version": "7",
+      "when": 1762251112601,
+      "tag": "0043_add_ai_model_settings",
+      "breakpoints": true
     }
   ],
   "version": "6"

package/packages/database/src/core/migrations.json

@@ -749,10 +749,18 @@
   },
   {
     "sql": [
-      "CREATE INDEX \"agents_knowledge_bases_agent_id_idx\" ON \"agents_knowledge_bases\" USING btree (\"agent_id\");"
+      "CREATE INDEX IF NOT EXISTS \"agents_knowledge_bases_agent_id_idx\" ON \"agents_knowledge_bases\" USING btree (\"agent_id\");\n"
     ],
     "bps": true,
     "folderMillis": 1762232313711,
-    "hash": "8988ec15592e000430d76566323f437b2ebde46122c5f7172067cd0a65f99614"
+    "hash": "fd8e7ff36bf877ddc1a45d360edfe1fe9a579cd02d68d7664545d7df95b8eb09"
+  },
+  {
+    "sql": [
+      "ALTER TABLE \"ai_models\" ADD COLUMN IF NOT EXISTS \"settings\" jsonb DEFAULT '{}'::jsonb;"
+    ],
+    "bps": true,
+    "folderMillis": 1762251112601,
+    "hash": "923ccbdf46c32be9a981dabd348e6923b4a365444241e9b8cc174bf5b914cbc5"
   }
 ]

package/packages/database/src/repositories/aiInfra/index.test.ts

@@ -731,6 +731,105 @@ describe('AiInfraRepos', () => {
       // 无 settings
       expect(merged?.settings).toBeUndefined();
     });
+
+    it('should prefer user settings over builtin settings', async () => {
+      const mockProviders = [
+        { enabled: true, id: 'openai', name: 'OpenAI', source: 'builtin' as const },
+      ];
+
+      const userModel: EnabledAiModel = {
+        id: 'gpt-4',
+        providerId: 'openai',
+        enabled: true,
+        type: 'chat',
+        abilities: {},
+        settings: { searchImpl: 'params', searchProvider: 'user-provider' },
+      };
+
+      const builtinModel = {
+        id: 'gpt-4',
+        enabled: true,
+        type: 'chat' as const,
+        settings: { searchImpl: 'tool', searchProvider: 'builtin-provider' },
+      };
+
+      vi.spyOn(repo, 'getAiProviderList').mockResolvedValue(mockProviders);
+      vi.spyOn(repo.aiModelModel, 'getAllModels').mockResolvedValue([userModel]);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue([builtinModel]);
+
+      const result = await repo.getEnabledModels();
+
+      const merged = result.find((m) => m.id === 'gpt-4');
+      expect(merged).toBeDefined();
+      // 应该使用用户的 settings，不是内置的
+      expect(merged?.settings).toEqual({ searchImpl: 'params', searchProvider: 'user-provider' });
+    });
+
+    it('should use builtin settings when user has no settings', async () => {
+      const mockProviders = [
+        { enabled: true, id: 'openai', name: 'OpenAI', source: 'builtin' as const },
+      ];
+
+      const userModel: EnabledAiModel = {
+        id: 'gpt-4',
+        providerId: 'openai',
+        enabled: true,
+        type: 'chat',
+        abilities: { vision: true },
+        // 用户未设置 settings
+      };
+
+      const builtinModel = {
+        id: 'gpt-4',
+        enabled: true,
+        type: 'chat' as const,
+        settings: { searchImpl: 'tool', searchProvider: 'google' },
+      };
+
+      vi.spyOn(repo, 'getAiProviderList').mockResolvedValue(mockProviders);
+      vi.spyOn(repo.aiModelModel, 'getAllModels').mockResolvedValue([userModel]);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue([builtinModel]);
+
+      const result = await repo.getEnabledModels();
+
+      const merged = result.find((m) => m.id === 'gpt-4');
+      expect(merged).toBeDefined();
+      // 应该使用内置的 settings
+      expect(merged?.settings).toEqual({ searchImpl: 'tool', searchProvider: 'google' });
+    });
+
+    it('should have no settings when both user and builtin have no settings', async () => {
+      const mockProviders = [
+        { enabled: true, id: 'openai', name: 'OpenAI', source: 'builtin' as const },
+      ];
+
+      const userModel: EnabledAiModel = {
+        id: 'gpt-4',
+        providerId: 'openai',
+        enabled: true,
+        type: 'chat',
+        abilities: { vision: true },
+        // 用户未设置 settings
+      };
+
+      const builtinModel = {
+        id: 'gpt-4',
+        enabled: true,
+        type: 'chat' as const,
+        // 内置也无 settings
+      };
+
+      vi.spyOn(repo, 'getAiProviderList').mockResolvedValue(mockProviders);
+      vi.spyOn(repo.aiModelModel, 'getAllModels').mockResolvedValue([userModel]);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue([builtinModel]);
+
+      const result = await repo.getEnabledModels();
+
+      const merged = result.find((m) => m.id === 'gpt-4');
+      expect(merged).toBeDefined();
+      // 无 settings
+      expect(merged?.settings).toBeUndefined();
+    });
   });
 
   describe('getAiProviderModelList', () => {
@@ -1270,6 +1369,105 @@ describe('AiInfraRepos', () => {
       // 无 settings
       expect(merged?.settings).toBeUndefined();
     });
+
+    it('should prefer user settings over builtin settings in getAiProviderModelList', async () => {
+      const providerId = 'openai';
+
+      const userModels: AiProviderModelListItem[] = [
+        {
+          id: 'gpt-4',
+          type: 'chat',
+          enabled: true,
+          abilities: {},
+          settings: { searchImpl: 'params', searchProvider: 'user-provider' },
+        } as any,
+      ];
+
+      const builtinModels: AiProviderModelListItem[] = [
+        {
+          id: 'gpt-4',
+          type: 'chat',
+          enabled: true,
+          settings: { searchImpl: 'tool', searchProvider: 'builtin-provider' },
+        } as any,
+      ];
+
+      vi.spyOn(repo.aiModelModel, 'getModelListByProviderId').mockResolvedValue(userModels);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue(builtinModels);
+
+      const result = await repo.getAiProviderModelList(providerId);
+
+      const merged = result.find((m) => m.id === 'gpt-4');
+      expect(merged).toBeDefined();
+      // 应该使用用户的 settings
+      expect(merged?.settings).toEqual({ searchImpl: 'params', searchProvider: 'user-provider' });
+    });
+
+    it('should use builtin settings when user has no settings in getAiProviderModelList', async () => {
+      const providerId = 'openai';
+
+      const userModels: AiProviderModelListItem[] = [
+        {
+          id: 'gpt-4',
+          type: 'chat',
+          enabled: true,
+          abilities: { vision: true },
+          // 用户未设置 settings
+        },
+      ];
+
+      const builtinModels: AiProviderModelListItem[] = [
+        {
+          id: 'gpt-4',
+          type: 'chat',
+          enabled: true,
+          settings: { searchImpl: 'tool', searchProvider: 'google' },
+        } as any,
+      ];
+
+      vi.spyOn(repo.aiModelModel, 'getModelListByProviderId').mockResolvedValue(userModels);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue(builtinModels);
+
+      const result = await repo.getAiProviderModelList(providerId);
+
+      const merged = result.find((m) => m.id === 'gpt-4');
+      expect(merged).toBeDefined();
+      // 应该使用内置的 settings
+      expect(merged?.settings).toEqual({ searchImpl: 'tool', searchProvider: 'google' });
+    });
+
+    it('should have no settings when both user and builtin have no settings in getAiProviderModelList', async () => {
+      const providerId = 'openai';
+
+      const userModels: AiProviderModelListItem[] = [
+        {
+          id: 'gpt-4',
+          type: 'chat',
+          enabled: true,
+          abilities: { vision: true },
+          // 用户未设置 settings
+        },
+      ];
+
+      const builtinModels: AiProviderModelListItem[] = [
+        {
+          id: 'gpt-4',
+          type: 'chat',
+          enabled: true,
+          // 内置也无 settings
+        },
+      ];
+
+      vi.spyOn(repo.aiModelModel, 'getModelListByProviderId').mockResolvedValue(userModels);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue(builtinModels);
+
+      const result = await repo.getAiProviderModelList(providerId);
+
+      const merged = result.find((m) => m.id === 'gpt-4');
+      expect(merged).toBeDefined();
+      // 无 settings
+      expect(merged?.settings).toBeUndefined();
+    });
   });
 
   describe('getAiProviderRuntimeState', () => {

package/packages/database/src/repositories/aiInfra/index.ts

@@ -91,6 +91,7 @@ const injectSearchSettings = (providerId: string, item: any) => {
     if (item?.settings?.searchImpl || item?.settings?.searchProvider) {
       const next = { ...item } as any;
       if (next.settings) {
+        // eslint-disable-next-line unused-imports/no-unused-vars, @typescript-eslint/no-unused-vars
         const { searchImpl, searchProvider, ...restSettings } = next.settings;
         next.settings = Object.keys(restSettings).length > 0 ? restSettings : undefined;
       }
@@ -224,7 +225,7 @@ export class AiInfraRepos {
               enabled: typeof user.enabled === 'boolean' ? user.enabled : item.enabled,
               id: item.id,
               providerId: provider.id,
-              settings: item.settings,
+              settings: user.settings || item.settings,
               sort: user.sort || undefined,
               type: user.type || item.type,
             };

package/packages/database/src/schemas/aiInfra.ts

@@ -1,5 +1,6 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix  */
 import { boolean, integer, jsonb, pgTable, primaryKey, text, varchar } from 'drizzle-orm/pg-core';
+import { AiModelSettings } from 'model-bank';
 
 import { AiProviderConfig, AiProviderSettings } from '@/types/aiProvider';
 
@@ -64,6 +65,7 @@ export const aiModels = pgTable(
     contextWindowTokens: integer('context_window_tokens'),
     source: varchar('source', { enum: ['remote', 'custom', 'builtin'], length: 20 }),
     releasedAt: varchar('released_at', { length: 10 }),
+    settings: jsonb('settings').default({}).$type<AiModelSettings>(),
 
     ...timestamps,
   },

package/packages/types/src/topic/topic.ts

@@ -51,3 +51,17 @@ export interface TopicRankItem {
   sessionId: string | null;
   title: string | null;
 }
+
+export interface CreateTopicParams {
+  favorite?: boolean;
+  groupId?: string | null;
+  messages?: string[];
+  sessionId?: string | null;
+  title: string;
+}
+
+export interface QueryTopicParams {
+  containerId?: string | null; // sessionId or groupId
+  current?: number;
+  pageSize?: number;
+}

package/src/server/routers/lambda/topic.ts

@@ -128,7 +128,13 @@ export const topicRouter = router({
     }),
 
   searchTopics: topicProcedure
-    .input(z.object({ keywords: z.string(), sessionId: z.string().nullable().optional() }))
+    .input(
+      z.object({
+        groupId: z.string().nullable().optional(),
+        keywords: z.string(),
+        sessionId: z.string().nullable().optional(),
+      }),
+    )
     .query(async ({ input, ctx }) => {
       return ctx.topicModel.queryByKeyword(input.keywords, input.sessionId);
     }),

package/src/services/aiModel/index.test.ts

@@ -1,7 +1,7 @@
 import { testService } from '~test-utils';
 
-import { ServerService } from './server';
+import { AiModelService } from './index';
 
-describe('aiModelService', () => {
-  testService(ServerService);
+describe('AiModelService', () => {
+  testService(AiModelService);
 });

package/src/services/aiModel/index.ts

@@ -1,3 +1,57 @@
-import { ServerService } from './server';
+import {
+  AiModelSortMap,
+  AiProviderModelListItem,
+  CreateAiModelParams,
+  ToggleAiModelEnableParams,
+  UpdateAiModelParams,
+} from 'model-bank';
 
-export const aiModelService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+
+export class AiModelService {
+  createAiModel = async (params: CreateAiModelParams) => {
+    return lambdaClient.aiModel.createAiModel.mutate(params);
+  };
+
+  getAiProviderModelList = async (id: string): Promise<AiProviderModelListItem[]> => {
+    return lambdaClient.aiModel.getAiProviderModelList.query({ id });
+  };
+
+  getAiModelById = async (id: string) => {
+    return lambdaClient.aiModel.getAiModelById.query({ id });
+  };
+
+  toggleModelEnabled = async (params: ToggleAiModelEnableParams) => {
+    return lambdaClient.aiModel.toggleModelEnabled.mutate(params);
+  };
+
+  updateAiModel = async (id: string, providerId: string, value: UpdateAiModelParams) => {
+    return lambdaClient.aiModel.updateAiModel.mutate({ id, providerId, value });
+  };
+
+  batchUpdateAiModels = async (id: string, models: AiProviderModelListItem[]) => {
+    return lambdaClient.aiModel.batchUpdateAiModels.mutate({ id, models });
+  };
+
+  batchToggleAiModels = async (id: string, models: string[], enabled: boolean) => {
+    return lambdaClient.aiModel.batchToggleAiModels.mutate({ enabled, id, models });
+  };
+
+  clearModelsByProvider = async (providerId: string) => {
+    return lambdaClient.aiModel.clearModelsByProvider.mutate({ providerId });
+  };
+
+  clearRemoteModels = async (providerId: string) => {
+    return lambdaClient.aiModel.clearRemoteModels.mutate({ providerId });
+  };
+
+  updateAiModelOrder = async (providerId: string, items: AiModelSortMap[]) => {
+    return lambdaClient.aiModel.updateAiModelOrder.mutate({ providerId, sortMap: items });
+  };
+
+  deleteAiModel = async (params: { id: string; providerId: string }) => {
+    return lambdaClient.aiModel.removeAiModel.mutate(params);
+  };
+}
+
+export const aiModelService = new AiModelService();

package/src/services/aiProvider/index.test.ts

@@ -1,7 +1,7 @@
 import { testService } from '~test-utils';
 
-import { ServerService } from './server';
+import { AiProviderService } from './index';
 
 describe('aiProviderService', () => {
-  testService(ServerService);
+  testService(AiProviderService);
 });

package/src/services/aiProvider/index.ts

@@ -1,3 +1,49 @@
-import { ServerService } from './server';
+import {
+  AiProviderDetailItem,
+  AiProviderRuntimeState,
+  AiProviderSortMap,
+  CreateAiProviderParams,
+  UpdateAiProviderConfigParams,
+} from '@/types/aiProvider';
 
-export const aiProviderService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+
+export class AiProviderService {
+  createAiProvider = async (params: CreateAiProviderParams) => {
+    return lambdaClient.aiProvider.createAiProvider.mutate(params);
+  };
+
+  getAiProviderList = async () => {
+    return lambdaClient.aiProvider.getAiProviderList.query();
+  };
+
+  getAiProviderById = async (id: string): Promise<AiProviderDetailItem | undefined> => {
+    return lambdaClient.aiProvider.getAiProviderById.query({ id });
+  };
+
+  toggleProviderEnabled = async (id: string, enabled: boolean) => {
+    return lambdaClient.aiProvider.toggleProviderEnabled.mutate({ enabled, id });
+  };
+
+  updateAiProvider = async (id: string, value: any) => {
+    return lambdaClient.aiProvider.updateAiProvider.mutate({ id, value });
+  };
+
+  updateAiProviderConfig = async (id: string, value: UpdateAiProviderConfigParams) => {
+    return lambdaClient.aiProvider.updateAiProviderConfig.mutate({ id, value });
+  };
+
+  updateAiProviderOrder = async (items: AiProviderSortMap[]) => {
+    return lambdaClient.aiProvider.updateAiProviderOrder.mutate({ sortMap: items });
+  };
+
+  deleteAiProvider = async (id: string) => {
+    return lambdaClient.aiProvider.removeAiProvider.mutate({ id });
+  };
+
+  getAiProviderRuntimeState = async (isLogin?: boolean): Promise<AiProviderRuntimeState> => {
+    return lambdaClient.aiProvider.getAiProviderRuntimeState.query({ isLogin });
+  };
+}
+
+export const aiProviderService = new AiProviderService();

package/src/services/chatGroup/index.ts

@@ -1,3 +1,67 @@
-import { ServerService } from './server';
+import {
+  ChatGroupAgentItem,
+  ChatGroupItem,
+  NewChatGroup,
+  NewChatGroupAgent,
+} from '@/database/schemas';
+import { lambdaClient } from '@/libs/trpc/client';
 
-export const chatGroupService = new ServerService();
+class ChatGroupService {
+  createGroup = (params: Omit<NewChatGroup, 'userId'>): Promise<ChatGroupItem> => {
+    return lambdaClient.group.createGroup.mutate({
+      ...params,
+      config: params.config as any,
+    });
+  };
+
+  updateGroup = (id: string, value: Partial<ChatGroupItem>): Promise<ChatGroupItem> => {
+    return lambdaClient.group.updateGroup.mutate({
+      id,
+      value: {
+        ...value,
+        config: value.config as any,
+      },
+    });
+  };
+
+  deleteGroup = (id: string) => {
+    return lambdaClient.group.deleteGroup.mutate({ id });
+  };
+
+  getGroup = (id: string): Promise<ChatGroupItem | undefined> => {
+    return lambdaClient.group.getGroup.query({ id });
+  };
+
+  getGroups = (): Promise<ChatGroupItem[]> => {
+    return lambdaClient.group.getGroups.query();
+  };
+
+  addAgentsToGroup = (groupId: string, agentIds: string[]): Promise<ChatGroupAgentItem[]> => {
+    return lambdaClient.group.addAgentsToGroup.mutate({ agentIds, groupId });
+  };
+
+  removeAgentsFromGroup = (groupId: string, agentIds: string[]) => {
+    return lambdaClient.group.removeAgentsFromGroup.mutate({ agentIds, groupId });
+  };
+
+  updateAgentInGroup = (
+    groupId: string,
+    agentId: string,
+    updates: Partial<Pick<NewChatGroupAgent, 'order' | 'role'>>,
+  ): Promise<ChatGroupAgentItem> => {
+    return lambdaClient.group.updateAgentInGroup.mutate({
+      agentId,
+      groupId,
+      updates: {
+        order: updates.order === null ? undefined : updates.order,
+        role: updates.role === null ? undefined : updates.role,
+      },
+    });
+  };
+
+  getGroupAgents = (groupId: string): Promise<ChatGroupAgentItem[]> => {
+    return lambdaClient.group.getGroupAgents.query({ groupId });
+  };
+}
+
+export const chatGroupService = new ChatGroupService();

package/src/services/export/index.ts

@@ -1,3 +1,11 @@
-import { ServerService } from './server';
+import { ExportDatabaseData } from '@/types/export';
 
-export const exportService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+
+class ExportService {
+  exportData = async (): Promise<ExportDatabaseData> => {
+    return await lambdaClient.exporter.exportData.mutate();
+  };
+}
+
+export const exportService = new ExportService();

package/src/services/file/index.ts

@@ -1,3 +1,62 @@
-import { ServerService } from './server';
+import { lambdaClient } from '@/libs/trpc/client';
+import {
+  CheckFileHashResult,
+  FileItem,
+  QueryFileListParams,
+  QueryFileListSchemaType,
+  UploadFileParams,
+} from '@/types/files';
 
-export const fileService = new ServerService();
+interface CreateFileParams extends Omit<UploadFileParams, 'url'> {
+  knowledgeBaseId?: string;
+  url: string;
+}
+
+export class FileService {
+  createFile = async (
+    params: UploadFileParams,
+    knowledgeBaseId?: string,
+  ): Promise<{ id: string; url: string }> => {
+    return lambdaClient.file.createFile.mutate({ ...params, knowledgeBaseId } as CreateFileParams);
+  };
+
+  getFile = async (id: string): Promise<FileItem> => {
+    const item = await lambdaClient.file.findById.query({ id });
+
+    if (!item) {
+      throw new Error('file not found');
+    }
+
+    return { ...item, type: item.fileType };
+  };
+
+  removeFile = async (id: string): Promise<void> => {
+    await lambdaClient.file.removeFile.mutate({ id });
+  };
+
+  removeFiles = async (ids: string[]): Promise<void> => {
+    await lambdaClient.file.removeFiles.mutate({ ids });
+  };
+
+  removeAllFiles = async () => {
+    await lambdaClient.file.removeAllFiles.mutate();
+  };
+
+  getFiles = async (params: QueryFileListParams) => {
+    return lambdaClient.file.getFiles.query(params as QueryFileListSchemaType);
+  };
+
+  getFileItem = async (id: string) => {
+    return lambdaClient.file.getFileItemById.query({ id });
+  };
+
+  checkFileHash = async (hash: string): Promise<CheckFileHashResult> => {
+    return lambdaClient.file.checkFileHash.mutate({ hash });
+  };
+
+  removeFileAsyncTask = async (id: string, type: 'embedding' | 'chunk') => {
+    return lambdaClient.file.removeFileAsyncTask.mutate({ id, type });
+  };
+}
+
+export const fileService = new FileService();