new framwork

client/src/service/utils/chat/claude.ts

@@ -0,0 +1,77 @@
+import { ChatCompletionType, StreamResponseType } from './index';
+import { ChatRoleEnum } from '@/constants/chat';
+import axios from 'axios';
+
+/* 模型对话 */
+export const claudChat = async ({ apiKey, messages, stream, chatId }: ChatCompletionType) => {
+  // get system prompt
+  const systemPrompt = messages
+    .filter((item) => item.obj === 'System')
+    .map((item) => item.value)
+    .join('\n');
+  const systemPromptText = systemPrompt ? `你本次知识:${systemPrompt}\n下面是我的问题:` : '';
+
+  const prompt = `${systemPromptText}'${messages[messages.length - 1].value}'`;
+
+  const response = await axios.post(
+    process.env.CLAUDE_BASE_URL || '',
+    {
+      prompt,
+      stream,
+      conversationId: chatId
+    },
+    {
+      headers: {
+        Authorization: apiKey
+      },
+      timeout: stream ? 60000 : 240000,
+      responseType: stream ? 'stream' : 'json'
+    }
+  );
+
+  const responseText = stream ? '' : response.data?.text || '';
+
+  return {
+    streamResponse: response,
+    responseMessages: messages.concat({
+      obj: ChatRoleEnum.AI,
+      value: responseText
+    }),
+    responseText,
+    totalTokens: 0
+  };
+};
+
+/* openai stream response */
+export const claudStreamResponse = async ({ res, chatResponse, prompts }: StreamResponseType) => {
+  try {
+    let responseContent = '';
+
+    try {
+      const decoder = new TextDecoder();
+      for await (const chunk of chatResponse.data as any) {
+        if (res.closed) {
+          break;
+        }
+        const content = decoder.decode(chunk);
+        responseContent += content;
+        content && res.write(content);
+      }
+    } catch (error) {
+      console.log('pipe error', error);
+    }
+
+    const finishMessages = prompts.concat({
+      obj: ChatRoleEnum.AI,
+      value: responseContent
+    });
+
+    return {
+      responseContent,
+      totalTokens: 0,
+      finishMessages
+    };
+  } catch (error) {
+    return Promise.reject(error);
+  }
+};

client/src/service/utils/chat/index.ts

@@ -0,0 +1,167 @@
+import { ChatItemSimpleType } from '@/types/chat';
+import { modelToolMap } from '@/utils/plugin';
+import type { ChatModelType } from '@/constants/model';
+import { ChatRoleEnum } from '@/constants/chat';
+import { OpenAiChatEnum, ClaudeEnum } from '@/constants/model';
+import { chatResponse, openAiStreamResponse } from './openai';
+import { claudChat, claudStreamResponse } from './claude';
+import type { NextApiResponse } from 'next';
+
+export type ChatCompletionType = {
+  apiKey: string;
+  temperature: number;
+  messages: ChatItemSimpleType[];
+  chatId?: string;
+  [key: string]: any;
+};
+export type ChatCompletionResponseType = {
+  streamResponse: any;
+  responseMessages: ChatItemSimpleType[];
+  responseText: string;
+  totalTokens: number;
+};
+export type StreamResponseType = {
+  chatResponse: any;
+  prompts: ChatItemSimpleType[];
+  res: NextApiResponse;
+  [key: string]: any;
+};
+export type StreamResponseReturnType = {
+  responseContent: string;
+  totalTokens: number;
+  finishMessages: ChatItemSimpleType[];
+};
+
+export const modelServiceToolMap: Record<
+  ChatModelType,
+  {
+    chatCompletion: (data: ChatCompletionType) => Promise<ChatCompletionResponseType>;
+    streamResponse: (data: StreamResponseType) => Promise<StreamResponseReturnType>;
+  }
+> = {
+  [OpenAiChatEnum.GPT35]: {
+    chatCompletion: (data: ChatCompletionType) =>
+      chatResponse({ model: OpenAiChatEnum.GPT35, ...data }),
+    streamResponse: (data: StreamResponseType) =>
+      openAiStreamResponse({
+        model: OpenAiChatEnum.GPT35,
+        ...data
+      })
+  },
+  [OpenAiChatEnum.GPT4]: {
+    chatCompletion: (data: ChatCompletionType) =>
+      chatResponse({ model: OpenAiChatEnum.GPT4, ...data }),
+    streamResponse: (data: StreamResponseType) =>
+      openAiStreamResponse({
+        model: OpenAiChatEnum.GPT4,
+        ...data
+      })
+  },
+  [OpenAiChatEnum.GPT432k]: {
+    chatCompletion: (data: ChatCompletionType) =>
+      chatResponse({ model: OpenAiChatEnum.GPT432k, ...data }),
+    streamResponse: (data: StreamResponseType) =>
+      openAiStreamResponse({
+        model: OpenAiChatEnum.GPT432k,
+        ...data
+      })
+  },
+  [ClaudeEnum.Claude]: {
+    chatCompletion: claudChat,
+    streamResponse: claudStreamResponse
+  }
+};
+
+/* delete invalid symbol */
+const simplifyStr = (str: string) =>
+  str
+    .replace(/\n+/g, '\n') // 连续空行
+    .replace(/[^\S\r\n]+/g, ' ') // 连续空白内容
+    .trim();
+
+/* 聊天上下文 tokens 截断 */
+export const ChatContextFilter = ({
+  model,
+  prompts,
+  maxTokens
+}: {
+  model: ChatModelType;
+  prompts: ChatItemSimpleType[];
+  maxTokens: number;
+}) => {
+  const systemPrompts: ChatItemSimpleType[] = [];
+  const chatPrompts: ChatItemSimpleType[] = [];
+
+  let rawTextLen = 0;
+  prompts.forEach((item) => {
+    const val = simplifyStr(item.value);
+    rawTextLen += val.length;
+
+    const data = {
+      obj: item.obj,
+      value: val
+    };
+
+    if (item.obj === ChatRoleEnum.System) {
+      systemPrompts.push(data);
+    } else {
+      chatPrompts.push(data);
+    }
+  });
+
+  // 长度太小时，不需要进行 token 截断
+  if (rawTextLen < maxTokens * 0.5) {
+    return [...systemPrompts, ...chatPrompts];
+  }
+
+  // 去掉 system 的 token
+  maxTokens -= modelToolMap[model].countTokens({
+    messages: systemPrompts
+  });
+
+  // 根据 tokens 截断内容
+  const chats: ChatItemSimpleType[] = [];
+
+  // 从后往前截取对话内容
+  for (let i = chatPrompts.length - 1; i >= 0; i--) {
+    chats.unshift(chatPrompts[i]);
+
+    const tokens = modelToolMap[model].countTokens({
+      messages: chats
+    });
+
+    /* 整体 tokens 超出范围, system必须保留 */
+    if (tokens >= maxTokens) {
+      chats.shift();
+      break;
+    }
+  }
+
+  return [...systemPrompts, ...chats];
+};
+
+/* stream response */
+export const resStreamResponse = async ({
+  model,
+  res,
+  chatResponse,
+  prompts
+}: StreamResponseType & {
+  model: ChatModelType;
+}) => {
+  // 创建响应流
+  res.setHeader('Content-Type', 'text/event-stream;charset-utf-8');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('X-Accel-Buffering', 'no');
+  res.setHeader('Cache-Control', 'no-cache, no-transform');
+
+  const { responseContent, totalTokens, finishMessages } = await modelServiceToolMap[
+    model
+  ].streamResponse({
+    chatResponse,
+    prompts,
+    res
+  });
+
+  return { responseContent, totalTokens, finishMessages };
+};

client/src/service/utils/chat/openai.ts

@@ -0,0 +1,120 @@
+import { Configuration, OpenAIApi } from 'openai';
+import { createParser, ParsedEvent, ReconnectInterval } from 'eventsource-parser';
+import { axiosConfig } from '../tools';
+import { ChatModelMap, OpenAiChatEnum } from '@/constants/model';
+import { adaptChatItem_openAI } from '@/utils/plugin/openai';
+import { modelToolMap } from '@/utils/plugin';
+import { ChatCompletionType, ChatContextFilter, StreamResponseType } from './index';
+import { ChatRoleEnum } from '@/constants/chat';
+
+export const getOpenAIApi = () =>
+  new OpenAIApi(
+    new Configuration({
+      basePath: process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1'
+    })
+  );
+
+/* 模型对话 */
+export const chatResponse = async ({
+  model,
+  apiKey,
+  temperature,
+  messages,
+  stream
+}: ChatCompletionType & { model: `${OpenAiChatEnum}` }) => {
+  const filterMessages = ChatContextFilter({
+    model,
+    prompts: messages,
+    maxTokens: Math.ceil(ChatModelMap[model].contextMaxToken * 0.85)
+  });
+
+  const adaptMessages = adaptChatItem_openAI({ messages: filterMessages });
+  const chatAPI = getOpenAIApi();
+
+  const response = await chatAPI.createChatCompletion(
+    {
+      model,
+      temperature: Number(temperature) || 0,
+      messages: adaptMessages,
+      frequency_penalty: 0.5, // 越大，重复内容越少
+      presence_penalty: -0.5, // 越大，越容易出现新内容
+      stream,
+      stop: ['.!?。']
+    },
+    {
+      timeout: stream ? 60000 : 240000,
+      responseType: stream ? 'stream' : 'json',
+      ...axiosConfig(apiKey)
+    }
+  );
+
+  const responseText = stream ? '' : response.data.choices[0].message?.content || '';
+  const totalTokens = stream ? 0 : response.data.usage?.total_tokens || 0;
+
+  return {
+    streamResponse: response,
+    responseMessages: filterMessages.concat({ obj: 'AI', value: responseText }),
+    responseText,
+    totalTokens
+  };
+};
+
+/* openai stream response */
+export const openAiStreamResponse = async ({
+  res,
+  model,
+  chatResponse,
+  prompts
+}: StreamResponseType & {
+  model: `${OpenAiChatEnum}`;
+}) => {
+  try {
+    let responseContent = '';
+
+    const onParse = async (event: ParsedEvent | ReconnectInterval) => {
+      if (event.type !== 'event') return;
+      const data = event.data;
+      if (data === '[DONE]') return;
+      try {
+        const json = JSON.parse(data);
+        const content: string = json?.choices?.[0].delta.content || '';
+        responseContent += content;
+
+        !res.closed && content && res.write(content);
+      } catch (error) {
+        error;
+      }
+    };
+
+    try {
+      const decoder = new TextDecoder();
+      const parser = createParser(onParse);
+      for await (const chunk of chatResponse.data as any) {
+        if (res.closed) {
+          break;
+        }
+        parser.feed(decoder.decode(chunk, { stream: true }));
+      }
+    } catch (error) {
+      console.log('pipe error', error);
+    }
+
+    // count tokens
+    const finishMessages = prompts.concat({
+      obj: ChatRoleEnum.AI,
+      value: responseContent
+    });
+
+    const totalTokens = modelToolMap[model].countTokens({
+      messages: finishMessages
+    });
+
+    return {
+      responseContent,
+      totalTokens,
+      finishMessages
+    };
+  } catch (error) {
+    return Promise.reject(error);
+  }
+};