Merge pull request #111 from solidSpoon/migrate-to-ai-sdk

migrate from LangChain to AI SDK

Author: solidSpoon

package.json

@@ -1,7 +1,7 @@
 {
     "name": "dash-player",
     "productName": "DashPlayer",
-    "version": "5.1.2",
+    "version": "5.1.3",
     "description": "My Electron application description",
     "main": ".vite/build/main.js",
     "scripts": {
@@ -55,11 +55,11 @@
         "vitest": "^1.3.1"
     },
     "dependencies": {
+        "@ai-sdk/openai": "^1.1.11",
         "@electron-forge/publisher-github": "^7.4.0",
         "@ffmpeg-installer/ffmpeg": "^1.1.0",
         "@floating-ui/react": "^0.26.9",
         "@hookform/resolvers": "^3.9.1",
-        "@langchain/core": "^0.3.5",
         "@radix-ui/react-aspect-ratio": "^1.1.0",
         "@radix-ui/react-checkbox": "^1.0.4",
         "@radix-ui/react-context-menu": "^2.1.5",
@@ -82,6 +82,7 @@
         "@types/fluent-ffmpeg": "^2.1.24",
         "@uidotdev/usehooks": "^2.4.1",
         "@vitejs/plugin-react": "^4.2.1",
+        "ai": "^4.1.41",
         "axios": "^1.6.8",
         "better-sqlite3": "^9.4.0",
         "class-variance-authority": "^0.7.0",
@@ -106,7 +107,6 @@
         "iconv-lite": "^0.6.3",
         "inversify": "^6.0.2",
         "jschardet": "^3.1.2",
-        "langchain": "^0.3.2",
         "leven": "^3.1.0",
         "lucide-react": "^0.378.0",
         "moment": "^2.30.1",

src/backend/controllers/AiFuncController.ts

@@ -2,13 +2,13 @@ import TtsService from '@/backend/services/TtsService';
 import registerRoute from '@/common/api/register';
 import AiServiceImpl from '@/backend/services/AiServiceImpl';
 import ChatServiceImpl from '@/backend/services/impl/ChatServiceImpl';
-import { MsgT, toLangChainMsg } from '@/common/types/msg/interfaces/MsgT';
 import UrlUtil from '@/common/utils/UrlUtil';
 import { inject, injectable } from 'inversify';
 import Controller from '@/backend/interfaces/controller';
 import TYPES from '@/backend/ioc/types';
 import DpTaskService from '@/backend/services/DpTaskService';
 import WhisperService from '@/backend/services/WhisperService';
+import { CoreMessage } from 'ai';
 
 @injectable()
 export default class AiFuncController implements Controller {
@@ -83,10 +83,9 @@ export default class AiFuncController implements Controller {
         return UrlUtil.dp(await TtsService.tts(string));
     }
 
-    public async chat({ msgs }: { msgs: MsgT[] }): Promise<number> {
+    public async chat({ msgs }: { msgs: CoreMessage[] }): Promise<number> {
         const taskId = await this.dpTaskService.create();
-        const ms = msgs.map((msg) => toLangChainMsg(msg));
-        this.chatService.chat(taskId, ms).then();
+        this.chatService.chat(taskId, msgs).then();
         return taskId;
     }
 

src/backend/ioc/inversify.config.ts

@@ -49,7 +49,6 @@ import MediaServiceImpl from '@/backend/services/impl/MediaServiceImpl';
 import ClientProviderService from '@/backend/services/ClientProviderService';
 import YouDaoProvider from '@/backend/services/impl/clients/YouDaoProvider';
 import TencentProvider from '@/backend/services/impl/clients/TencentProvider';
-import { ChatOpenAI } from '@langchain/openai';
 import TranslateServiceImpl from '@/backend/services/impl/TranslateServiceImpl';
 import TranslateService from '@/backend/services/AiTransServiceImpl';
 import TagServiceImpl from '@/backend/services/impl/TagServiceImpl';
@@ -62,13 +61,14 @@ import WatchHistoryServiceImpl from '@/backend/services/impl/WatchHistoryService
 import WatchHistoryController from '@/backend/controllers/WatchHistoryController';
 import { OpenAIServiceImpl } from '@/backend/services/impl/OpenAIServiceImpl';
 import { OpenAiService } from '@/backend/services/OpenAiService';
+import AiProviderService from '@/backend/services/AiProviderService';
 
 
 const container = new Container();
 // Clients
 container.bind<ClientProviderService<YouDaoClient>>(TYPES.YouDaoClientProvider).to(YouDaoProvider).inSingletonScope();
 container.bind<ClientProviderService<TencentClient>>(TYPES.TencentClientProvider).to(TencentProvider).inSingletonScope();
-container.bind<ClientProviderService<ChatOpenAI>>(TYPES.OpenAiClientProvider).to(AiProviderServiceImpl).inSingletonScope();
+container.bind<AiProviderService>(TYPES.AiProviderService).to(AiProviderServiceImpl).inSingletonScope();
 // Controllers
 container.bind<Controller>(TYPES.Controller).to(FavoriteClipsController).inSingletonScope();
 container.bind<Controller>(TYPES.Controller).to(DownloadVideoController).inSingletonScope();

src/backend/ioc/types.ts

@@ -25,7 +25,7 @@ const TYPES = {
     // Clients
     YouDaoClientProvider: Symbol('YouDaoClientProvider'),
     TencentClientProvider: Symbol('TencentClientProvider'),
-    OpenAiClientProvider: Symbol('OpenAiClientProvider'),
+    AiProviderService: Symbol('AiProviderService'),
 };
 
 export default TYPES;

src/backend/services/AiProviderService.ts

@@ -0,0 +1,5 @@
+import { LanguageModelV1 } from 'ai';
+
+export default interface AiProviderService {
+    getModel(): LanguageModelV1 | null;
+}

src/backend/services/AiServiceImpl.ts

@@ -15,7 +15,6 @@ import { getSubtitleContent, srtSlice } from '@/common/utils/srtSlice';
 import { inject, injectable } from 'inversify';
 import TYPES from '@/backend/ioc/types';
 import ChatService from '@/backend/services/ChatService';
-import { HumanMessage } from '@langchain/core/messages';
 
 export interface AiService {
     polish(taskId: number, sentence: string): Promise<void>;
@@ -55,7 +54,10 @@ export default class AiServiceImpl implements AiService {
 
     public async formatSplit(taskId: number, text: string) {
         // await AiFunc.run(taskId, null, AiFuncFormatSplitPrompt.promptFunc(text));
-        await this.chatService.chat(taskId, [new HumanMessage(AiFuncFormatSplitPrompt.promptFunc(text))]);
+        await this.chatService.chat(taskId, [{
+            role: 'user',
+            content: AiFuncFormatSplitPrompt.promptFunc(text)
+        }]);
     }
 
     public async analyzeWord(taskId: number, sentence: string) {

src/backend/services/ChatService.ts

@@ -1,8 +1,8 @@
-import { BaseMessage } from '@langchain/core/messages';
 import { ZodObject } from 'zod';
+import { CoreMessage } from 'ai';
 
 export default interface ChatService {
-    chat(taskId: number, msgs: BaseMessage[]): Promise<void>;
+    chat(taskId: number, msgs: CoreMessage[]): Promise<void>;
     run(taskId: number, resultSchema: ZodObject<any>, promptStr: string): Promise<void>;
 }
 

src/backend/services/impl/ChatServiceImpl.ts

@@ -1,44 +1,41 @@
 import RateLimiter from '@/common/utils/RateLimiter';
-import { BaseMessage } from '@langchain/core/messages';
 import { inject, injectable } from 'inversify';
 import DpTaskService from '@/backend/services/DpTaskService';
 import TYPES from '@/backend/ioc/types';
 import ChatService from '@/backend/services/ChatService';
-import { ChatOpenAI } from '@langchain/openai';
-import ClientProviderService from '@/backend/services/ClientProviderService';
 import { ZodObject } from 'zod';
-import { storeGet } from '@/backend/store';
-
-
+import { CoreMessage, streamObject, streamText } from 'ai';
+import AiProviderService from '@/backend/services/AiProviderService';
 @injectable()
 export default class ChatServiceImpl implements ChatService {
 
     @inject(TYPES.DpTaskService)
     private dpTaskService!: DpTaskService;
 
-    @inject(TYPES.OpenAiClientProvider)
-    private aiProviderService!: ClientProviderService<ChatOpenAI>;
+    @inject(TYPES.AiProviderService)
+    private aiProviderService!: AiProviderService;
 
 
-    public async chat(taskId: number, msgs: BaseMessage[]) {
+    public async chat(taskId: number, msgs: CoreMessage[]) {
         await RateLimiter.wait('gpt');
-        const chat = this.aiProviderService.getClient();
-        if (chat) {
+        const model = this.aiProviderService.getModel();
+        if (!model) {
             this.dpTaskService.fail(taskId, {
                 progress: 'OpenAI api key or endpoint is empty'
             });
+            return;
         }
         this.dpTaskService.process(taskId, {
             progress: 'AI is thinking...'
         });
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        const resStream = await chat.stream(msgs);
-        const chunks = [];
+
+        const result = streamText({
+            model: model,
+            messages: msgs
+        });
         let res = '';
-        for await (const chunk of resStream) {
-            res += chunk.content;
-            chunks.push(chunk);
+        for await (const chunk of result.textStream) {
+            res += chunk;
             this.dpTaskService.process(taskId, {
                 progress: `AI typing, ${res.length} characters`,
                 result: res
@@ -52,38 +49,29 @@ export default class ChatServiceImpl implements ChatService {
 
     public async run(taskId: number, resultSchema: ZodObject<any>, promptStr: string) {
         await RateLimiter.wait('gpt');
-        const chat = this.aiProviderService.getClient();
-        if (!chat) {
+        const model = this.aiProviderService.getModel();
+        if (!model) {
             this.dpTaskService.fail(taskId, {
                 progress: 'OpenAI api key or endpoint is empty'
             });
             return;
         }
-        const structuredLlm = chat.withStructuredOutput(resultSchema);
-
+        const { partialObjectStream } = streamObject({
+            model: model,
+            schema: resultSchema,
+            prompt: promptStr,
+        });
         this.dpTaskService.process(taskId, {
             progress: 'AI is analyzing...'
         });
-
-        const streaming = storeGet('apiKeys.openAi.stream') === 'on';
-
-        let resStr = null;
-        if (streaming) {
-            const resStream = await structuredLlm.stream(promptStr);
-            for await (const chunk of resStream) {
-                resStr = JSON.stringify(chunk);
-                this.dpTaskService.process(taskId, {
-                    progress: 'AI is analyzing...',
-                    result: resStr
-                });
-            }
-        } else {
-            const res = await structuredLlm.invoke(promptStr);
-            resStr = JSON.stringify(res);
+        for await (const partialObject of partialObjectStream) {
+            this.dpTaskService.process(taskId, {
+                progress: 'AI is analyzing...',
+                result: JSON.stringify(partialObject)
+            });
         }
         this.dpTaskService.finish(taskId, {
-            progress: 'AI has responded',
-            result: resStr
+            progress: 'AI has responded'
         });
     }
 }

src/backend/services/impl/clients/AiProviderServiceImpl.ts

@@ -1,14 +1,16 @@
-import { ChatOpenAI } from '@langchain/openai';
 import { storeGet } from '@/backend/store';
 import StrUtil from '@/common/utils/str-util';
 import { joinUrl } from '@/common/utils/Util';
 import { injectable } from 'inversify';
-import ClientProviderService from '@/backend/services/ClientProviderService';
+import AiProviderService from '@/backend/services/AiProviderService';
+import { createOpenAI } from '@ai-sdk/openai';
+import { LanguageModelV1 } from 'ai';
 
 
 @injectable()
-export default class AiProviderServiceImpl implements ClientProviderService<ChatOpenAI> {
-    public getClient(): ChatOpenAI | null {
+export default class AiProviderServiceImpl implements AiProviderService {
+
+    public getModel():LanguageModelV1 | null {
         const apiKey = storeGet('apiKeys.openAi.key');
         const endpoint = storeGet('apiKeys.openAi.endpoint');
         let model = storeGet('model.gpt.default');
@@ -18,14 +20,11 @@ export default class AiProviderServiceImpl implements ClientProviderService<Chat
         if (StrUtil.hasBlank(apiKey, endpoint)) {
             return null;
         }
-        console.log(apiKey, endpoint);
-        return new ChatOpenAI({
-            modelName: model,
-            temperature: 0.7,
-            openAIApiKey: apiKey,
-            configuration: {
-                baseURL: joinUrl(endpoint, '/v1')
-            },
+        const openai = createOpenAI({
+            compatibility: 'compatible',
+            baseURL: joinUrl(endpoint, '/v1'),
+            apiKey: apiKey
         });
+        return openai(model);
     }
 }

src/common/api/api-def.ts

@@ -1,4 +1,3 @@
-import { MsgT } from '@/common/types/msg/interfaces/MsgT';
 import { DpTask } from '@/backend/db/tables/dpTask';
 import { YdRes } from '@/common/types/YdRes';
 import { ChapterParseResult } from '@/common/types/chapter-result';
@@ -16,6 +15,7 @@ import { ClipQuery } from '@/common/api/dto';
 import { ClipMeta, OssBaseMeta } from '@/common/types/clipMeta';
 import WatchHistoryVO from '@/common/types/WatchHistoryVO';
 import { COOKIE } from '@/common/types/DlVideoType';
+import { CoreMessage } from 'ai';
 
 interface ApiDefinition {
     'eg': { params: string, return: number },
@@ -32,7 +32,7 @@ interface AiFuncDef {
     'ai-func/analyze-grammars': { params: string, return: number };
     'ai-func/analyze-new-phrases': { params: string, return: number };
     'ai-func/analyze-new-words': { params: string, return: number };
-    'ai-func/chat': { params: { msgs: MsgT[] }, return: number };
+    'ai-func/chat': { params: { msgs: CoreMessage[] }, return: number };
     'ai-func/transcript': { params: { filePath: string }, return: number };
     'ai-func/explain-select-with-context': { params: { sentence: string, selectedWord: string }, return: number };
     'ai-func/explain-select': { params: { word: string }, return: number };