🚧 wip: dify

src/app/(backend)/webapi/chat/[provider]/route.ts

@@ -10,6 +10,7 @@ export const runtime = 'edge';
 
 export const POST = checkAuth(async (req: Request, { params, jwtPayload, createRuntime }) => {
   const { provider } = params;
+  console.log(jwtPayload);
 
   try {
     // ============  1. init chat model   ============ //

src/const/settings/agent.ts

@@ -22,6 +22,12 @@ export const DEFAULT_AGENT_CHAT_CONFIG: LobeAgentChatConfig = {
 
 export const DEFAULT_AGENT_CONFIG: LobeAgentConfig = {
   chatConfig: DEFAULT_AGENT_CHAT_CONFIG,
+  dify: {
+    baseUrl: 'https://api.dify.ai/v1',
+    enabled: false,
+    token: '',
+    userId: 'devTest',
+  },
   model: DEFAULT_MODEL,
   params: {
     frequency_penalty: 0,
@@ -32,7 +38,7 @@ export const DEFAULT_AGENT_CONFIG: LobeAgentConfig = {
   plugins: [],
   provider: ModelProvider.OpenAI,
   systemRole: '',
-  tts: DEFAUTT_AGENT_TTS_CONFIG,
+  tts: DEFAUTT_AGENT_TTS_CONFIG
 };
 
 export const DEFAULT_AGENT: UserDefaultAgent = {

src/features/AgentSetting/AgentSettings.tsx

@@ -4,6 +4,7 @@ import AgentModal from './AgentModal';
 import AgentPlugin from './AgentPlugin';
 import AgentPrompt from './AgentPrompt';
 import AgentTTS from './AgentTTS';
+import Dify from './Dify'
 import StoreUpdater, { StoreUpdaterProps } from './StoreUpdater';
 import { Provider, createStore } from './store';
 
@@ -19,6 +20,7 @@ export const AgentSettings = (props: AgentSettingsProps) => {
       <AgentModal />
       <AgentTTS />
       <AgentPlugin />
+      <Dify />
     </Provider>
   );
 };

src/features/AgentSetting/Dify/index.tsx

@@ -0,0 +1,91 @@
+'use client';
+
+import { Form, type ItemGroup, Input } from '@lobehub/ui';
+import { Switch } from 'antd';
+import { memo, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { FORM_STYLE } from '@/const/layoutTokens';
+
+import { useStore } from '../store';
+import { useUserStore } from '@/store/user';
+
+const AgentMeta = memo(() => {
+  const { t } = useTranslation('setting');
+
+  const [setAgentConfig, agentConfig ] = useStore((s) => [
+    s.setAgentConfig,
+    s.config
+  ]);
+
+  const updateKeyVaultConfig = useUserStore((s)=>s.updateKeyVaultConfig)
+
+  const [difyBaseUrl, setDifyBaseUrl] = useState<string>('https://api.dify.ai/v1')
+  const [difyToken, setDifyToken] = useState<string>('app-1WHrUsnegCQqYgSjN952dHyt')
+  const [difyUserId, setDifyUserId] = useState<string>('dev')
+  const [difyEnabled, setDifyEnable] = useState<boolean>(true)
+
+  useEffect(() => {
+    setAgentConfig({
+      dify: {
+        baseUrl: difyBaseUrl,
+        token: difyToken,
+        userId: difyUserId,
+        enabled: difyEnabled,
+      },
+      provider: 'dify',
+      model: 'Dofy Workflow'
+    })
+    updateKeyVaultConfig('dify', {
+      baseUrl: difyBaseUrl,
+      token: difyToken,
+      userId: difyUserId,
+    })
+  }, [difyBaseUrl, difyToken, difyUserId, difyEnabled])
+
+  const metaData: ItemGroup = {
+    children: [
+      {
+        children: (
+          <Input 
+            onChange={(event) => setDifyBaseUrl(event.currentTarget.value)}
+            placeholder='https://api.dify.ai/v1' 
+            value={agentConfig.dify.baseUrl} />
+        ),
+        label: 'BaseUrl'
+      },
+      {
+        children: (
+          <Input 
+            onChange={(event) => setDifyToken(event.currentTarget.value)} 
+            value={agentConfig.dify.token}
+            />
+        ),
+        label: 'Token'
+      },
+      {
+        children: (
+          <Input 
+            onChange={(event) => setDifyUserId(event.currentTarget.value)} 
+            value={agentConfig.dify.userId}
+          />
+        ),
+        label: 'UserId'
+      },
+      {
+        children: (
+          <Switch 
+            onChange={setDifyEnable}
+            value={agentConfig.dify.enabled}
+          />
+        ),
+        label: 'BaseUrl'
+      }
+    ],
+    title: t('settingAgent.title'),
+  };
+
+  return <Form items={[metaData]} itemsType={'group'} variant={'pure'} {...FORM_STYLE} />;
+});
+
+export default AgentMeta;

src/features/AgentSetting/store/action.ts

@@ -58,8 +58,8 @@ export interface Action extends PublicAction {
   resetAgentMeta: () => void;
   setAgentConfig: (config: DeepPartial<LobeAgentConfig>) => void;
   setAgentMeta: (meta: Partial<MetaData>) => void;
-
   setChatConfig: (config: Partial<LobeAgentChatConfig>) => void;
+
   streamUpdateMetaArray: (key: keyof MetaData) => any;
   streamUpdateMetaString: (key: keyof MetaData) => any;
   toggleAgentPlugin: (pluginId: string, state?: boolean) => void;
@@ -291,6 +291,7 @@ export const store: StateCreator<Store, [['zustand/devtools', never]]> = (set, g
     };
   },
 
+
   toggleAgentPlugin: (id, state) => {
     get().dispatchConfig({ pluginId: id, state, type: 'togglePlugin' });
   },

src/libs/agent-runtime/AgentRuntime.ts

@@ -42,6 +42,7 @@ import {
 import { LobeUpstageAI } from './upstage';
 import { LobeZeroOneAI } from './zeroone';
 import { LobeZhipuAI } from './zhipu';
+import LobeDify from './dify';
 
 export interface AgentChatOptions {
   enableTrace?: boolean;
@@ -154,6 +155,7 @@ class AgentRuntime {
       upstage: Partial<ClientOptions>;
       zeroone: Partial<ClientOptions>;
       zhipu: Partial<ClientOptions>;
+      dify: Partial<{ baseUrl: string; token: string; userId: string; conversation_id: string}>;
     }>,
   ) {
     let runtimeModel: LobeRuntimeAI;
@@ -314,6 +316,12 @@ class AgentRuntime {
         runtimeModel = new LobeHunyuanAI(params.hunyuan);
         break;
       }
+
+      case ModelProvider.Dify: {
+        console.log('[initializeWithProviderOptions]: ', params.dify);
+        runtimeModel = new LobeDify(params.dify || {})
+        break
+      }
     }
 
     return new AgentRuntime(runtimeModel);

src/libs/agent-runtime/dify/index.ts

@@ -0,0 +1,82 @@
+import { ChatClient } from 'dify-client'
+import { LobeRuntimeAI } from '../BaseAI';
+import { AgentRuntimeErrorType } from '../error';
+import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from '../types';
+import { AgentRuntimeError } from '../utils/createError';
+import { StreamingResponse } from '../utils/response';
+import { DifyStream } from '../utils/streams/dify';
+import urlJoin from 'url-join';
+
+export interface DifyParams {
+  baseUrl: string
+  token?: string
+  userId: string
+  conversation_id?: string
+}
+
+export class LobeDify implements LobeRuntimeAI {
+  client: ChatClient;
+  difyParams: DifyParams
+
+  constructor({ baseUrl, token, userId, conversation_id }: Partial<DifyParams>) {
+    console.log('[LobeDify]: ', {baseUrl, token, userId, conversation_id});
+
+    if (!(userId && token))
+      throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey);
+
+    this.difyParams = {
+      baseUrl: baseUrl ?? 'https://api.dify.ai/v1',
+      conversation_id,
+      userId,
+      token,
+    }
+    this.client = new ChatClient(token, this.difyParams.baseUrl)
+  }
+
+  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
+    const { messages } = payload
+    // Get the last message as query
+    const query = messages.at(-1)
+    if (!query) {
+      throw new Error('[Dify]: No query')
+    }
+    let textQuery = ''
+    if (typeof query.content === 'string')
+      textQuery = query.content
+    else
+      throw new Error('[Dify]: Unsupport user message type')
+
+    console.log('[Dify]: textQuery', textQuery);
+
+    const response = await fetch(urlJoin(this.difyParams.baseUrl, '/chat-messages'), {
+      method: 'POST',
+      // signal: options?.signal,
+      headers: {
+        Authorization: `Bearer ${this.difyParams.token}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        query: textQuery,
+        user: this.difyParams.userId,
+        conversation_id: this.difyParams?.conversation_id ?? '',
+        response_mode: 'streaming',
+        inputs: [],
+        files: [],
+      })
+    })
+    if (!response.body || !response.ok) {
+      throw AgentRuntimeError.chat({
+        error: {
+          status: response.status,
+          statusText: response.statusText,
+        },
+        errorType: AgentRuntimeErrorType.ProviderBizError,
+        provider: ModelProvider.Dify,
+      });
+    }
+    const [prod, _] = response.body.tee();
+    return StreamingResponse(DifyStream(prod), { headers: options?.headers });
+  }
+}
+
+export default LobeDify;

src/libs/agent-runtime/index.ts

@@ -20,3 +20,4 @@ export * from './types';
 export { AgentRuntimeError } from './utils/createError';
 export { LobeZeroOneAI } from './zeroone';
 export { LobeZhipuAI } from './zhipu';
+export { LobeDify } from './dify'

src/libs/agent-runtime/types/type.ts

@@ -53,6 +53,7 @@ export enum ModelProvider {
   Wenxin = 'wenxin',
   ZeroOne = 'zeroone',
   ZhiPu = 'zhipu',
+  Dify = 'dify'
 }
 
 export type ModelProviderKey = Lowercase<keyof typeof ModelProvider>;

src/libs/agent-runtime/utils/streams/dify.ts

@@ -0,0 +1,67 @@
+import { convertIterableToStream, createCallbacksTransformer, createSSEProtocolTransformer, StreamProtocolChunk, StreamStack } from ".";
+import { ChatStreamCallbacks } from "../..";
+
+interface DifyChunk {
+    event: string;
+    task_id?: string;
+    answer?: string;
+    message?: string; // 错误信息
+    message_id?: string;
+    id?: string
+}
+
+const processDifyData = (buffer: string): DifyChunk => {
+    try {
+        // Remove the prefix `data:`
+        if (buffer.startsWith('data:'))
+            return JSON.parse(buffer.slice(5).trim()) as DifyChunk
+        return JSON.parse(buffer.trim())
+    } catch (error) {
+        console.error('[Dify - transformDifyStream - processDifyData]: ', {
+            error,
+            buffer,
+        })
+    }
+    return { raw: buffer } as any
+}
+
+export const transformDifyStream = (buffer: Uint8Array): StreamProtocolChunk => {
+    const decoder = new TextDecoder()
+    const chunk = processDifyData(decoder.decode(buffer, { stream: true }))
+    // console.log('[transformDifyStrem]: ', chunk);
+    let type: StreamProtocolChunk['type'] = 'text'
+    switch(chunk.event){
+        case 'message_end':
+            type = 'stop'
+            break;
+        case 'message':
+            type = 'text'
+            break;
+        case 'message_replace':
+            type = 'text'
+            break;
+        case 'workflow_started':
+            type = 'tool_calls'
+            break;
+        case 'node_started':
+            type = 'tool_calls'
+            break;
+        case 'node_finished ':
+            type = 'tool_calls'
+            break
+        case 'workflow_finished':
+            type = 'tool_calls'
+            break;
+    }
+    return {
+        id: chunk?.task_id ?? chunk?.id,
+        data: chunk,
+        type: type,
+    }
+}    
+
+export const DifyStream = (stream: ReadableStream, callbacks?: ChatStreamCallbacks) => {
+    return stream
+        .pipeThrough(createSSEProtocolTransformer(transformDifyStream))
+        .pipeThrough(createCallbacksTransformer(callbacks));
+};

src/server/modules/AgentRuntime/index.ts

@@ -263,6 +263,9 @@ const getLlmOptionsFromPayload = (provider: string, payload: JWTPayload) => {
 
       return { apiKey };
     }
+    case ModelProvider.Dify: {
+      return payload
+    }
   }
 };
 

src/services/_auth.ts

@@ -55,6 +55,15 @@ export const getProviderAuthPayload = (provider: string) => {
       return { endpoint: config?.baseURL };
     }
 
+    case ModelProvider.Dify: {
+      const { token, baseUrl, userId } = keyVaultsConfigSelectors.difyConfig(useUserStore.getState())
+      return {
+        token,
+        baseUrl,
+        userId,
+      }
+    }
+
     default: {
       const config = keyVaultsConfigSelectors.getVaultByProvider(provider as GlobalLLMProviderKey)(
         useUserStore.getState(),

src/services/chat.ts

@@ -165,6 +165,14 @@ export function initializeWithClientStore(provider: string, payload: any) {
     case ModelProvider.ZeroOne: {
       break;
     }
+    case ModelProvider.Dify: {
+      providerOptions = {
+        token: providerAuthPayload?.apiKey,
+        baseUrl: providerAuthPayload?.endpoint,
+        userId: providerAuthPayload?.userId,
+      }
+      break;
+    }
   }
 
   /**