@lobehub/chat 0.147.21 → 0.148.0

package/src/features/Conversation/components/ChatItem/index.tsx

@@ -19,6 +19,9 @@ import ActionsBar from './ActionsBar';
 import HistoryDivider from './HistoryDivider';
 
 const useStyles = createStyles(({ css, prefixCls }) => ({
+  loading: css`
+    opacity: 0.6;
+  `,
   message: css`
     // prevent the textarea too long
     .${prefixCls}-input {
@@ -35,7 +38,7 @@ export interface ChatListItemProps {
 const Item = memo<ChatListItemProps>(({ index, id }) => {
   const fontSize = useGlobalStore((s) => settingsSelectors.currentSettings(s).fontSize);
   const { t } = useTranslation('common');
-  const { styles } = useStyles();
+  const { styles, cx } = useStyles();
   const [editing, setEditing] = useState(false);
   const [type = 'chat'] = useSessionStore((s) => {
     const config = agentSelectors.currentAgentConfig(s);
@@ -54,10 +57,12 @@ const Item = memo<ChatListItemProps>(({ index, id }) => {
   const historyLength = useChatStore((s) => chatSelectors.currentChats(s).length);
 
   const [loading, updateMessageContent] = useChatStore((s) => [
-    s.chatLoadingId === id,
+    s.chatLoadingId === id || s.messageLoadingIds.includes(id),
     s.modifyMessageContent,
   ]);
 
+  const [isMessageLoading] = useChatStore((s) => [s.messageLoadingIds.includes(id)]);
+
   const onAvatarsClick = useAvatarsClick();
 
   const RenderMessage = useCallback(
@@ -110,7 +115,7 @@ const Item = memo<ChatListItemProps>(({ index, id }) => {
         <ChatItem
           actions={<ActionsBar index={index} setEditing={setEditing} />}
           avatar={item.meta}
-          className={styles.message}
+          className={cx(styles.message, isMessageLoading && styles.loading)}
           editing={editing}
           error={error}
           errorMessage={<ErrorMessageExtra data={item} />}

package/src/libs/agent-runtime/AgentRuntime.test.ts

@@ -0,0 +1,400 @@
+// @vitest-environment node
+import { Langfuse } from 'langfuse';
+import { LangfuseGenerationClient, LangfuseTraceClient } from 'langfuse-core';
+import { ClientOptions } from 'openai';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { createTraceOptions } from '@/app/api/chat/agentRuntime';
+import { getServerConfig } from '@/config/server';
+import { JWTPayload } from '@/const/auth';
+import { TraceNameMap } from '@/const/trace';
+import {
+  AgentRuntime,
+  ChatStreamPayload,
+  LobeAnthropicAI,
+  LobeAzureOpenAI,
+  LobeBedrockAI,
+  LobeGoogleAI,
+  LobeMistralAI,
+  LobeMoonshotAI,
+  LobeOllamaAI,
+  LobeOpenAI,
+  LobeOpenRouterAI,
+  LobePerplexityAI,
+  LobeRuntimeAI,
+  LobeTogetherAI,
+  LobeZhipuAI,
+  ModelProvider,
+} from '@/libs/agent-runtime';
+
+import { AgentChatOptions } from './AgentRuntime';
+import { LobeBedrockAIParams } from './bedrock';
+
+// 模拟依赖项
+vi.mock('@/config/server', () => ({
+  getServerConfig: vi.fn(() => ({
+    // 确保为每个provider提供必要的配置信息
+    OPENAI_API_KEY: 'test-openai-key',
+    GOOGLE_API_KEY: 'test-google-key',
+
+    AZURE_API_KEY: 'test-azure-key',
+    AZURE_ENDPOINT: 'endpoint',
+
+    ZHIPU_API_KEY: 'test.zhipu-key',
+    MOONSHOT_API_KEY: 'test-moonshot-key',
+    AWS_SECRET_ACCESS_KEY: 'test-aws-secret',
+    AWS_ACCESS_KEY_ID: 'test-aws-id',
+    AWS_REGION: 'test-aws-region',
+    OLLAMA_PROXY_URL: 'test-ollama-url',
+    PERPLEXITY_API_KEY: 'test-perplexity-key',
+    ANTHROPIC_API_KEY: 'test-anthropic-key',
+    MISTRAL_API_KEY: 'test-mistral-key',
+    OPENROUTER_API_KEY: 'test-openrouter-key',
+    TOGETHERAI_API_KEY: 'test-togetherai-key',
+  })),
+}));
+
+describe('AgentRuntime', () => {
+  describe('should initialize with various providers', () => {
+    describe('OpenAI provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: ClientOptions = { apiKey: 'user-openai-key', baseURL: 'user-endpoint' };
+
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.OpenAI, {
+          openai: jwtPayload,
+        });
+
+        expect(runtime).toBeInstanceOf(AgentRuntime);
+        expect(runtime['_runtime']).toBeInstanceOf(LobeOpenAI);
+        expect(runtime['_runtime'].baseURL).toBe('user-endpoint');
+      });
+    });
+
+    describe('Azure OpenAI provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload = {
+          apikey: 'user-azure-key',
+          endpoint: 'user-azure-endpoint',
+          apiVersion: '2024-02-01',
+        };
+
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Azure, {
+          azure: jwtPayload,
+        });
+
+        expect(runtime).toBeInstanceOf(AgentRuntime);
+        expect(runtime['_runtime']).toBeInstanceOf(LobeAzureOpenAI);
+        expect(runtime['_runtime'].baseURL).toBe('user-azure-endpoint');
+      });
+      it('should initialize with azureOpenAIParams correctly', async () => {
+        const jwtPayload = {
+          apikey: 'user-openai-key',
+          endpoint: 'user-endpoint',
+          apiVersion: 'custom-version',
+        };
+
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Azure, {
+          azure: jwtPayload,
+        });
+
+        expect(runtime).toBeInstanceOf(AgentRuntime);
+        const openAIRuntime = runtime['_runtime'] as LobeRuntimeAI;
+        expect(openAIRuntime).toBeInstanceOf(LobeAzureOpenAI);
+      });
+
+      it('should initialize with AzureAI correctly', async () => {
+        const jwtPayload = {
+          apikey: 'user-azure-key',
+          endpoint: 'user-azure-endpoint',
+        };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Azure, {
+          azure: jwtPayload,
+        });
+
+        expect(runtime['_runtime']).toBeInstanceOf(LobeAzureOpenAI);
+      });
+    });
+
+    describe('ZhiPu AI provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: JWTPayload = { apiKey: 'zhipu.user-key' };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.ZhiPu, {
+          zhipu: jwtPayload,
+        });
+
+        // 假设 LobeZhipuAI 是 ZhiPu 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobeZhipuAI);
+      });
+    });
+
+    describe('Google provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: JWTPayload = { apiKey: 'user-google-key' };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Google, {
+          google: jwtPayload,
+        });
+
+        // 假设 LobeGoogleAI 是 Google 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobeGoogleAI);
+      });
+    });
+
+    describe('Moonshot AI provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: JWTPayload = { apiKey: 'user-moonshot-key' };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Moonshot, {
+          moonshot: jwtPayload,
+        });
+
+        // 假设 LobeMoonshotAI 是 Moonshot 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobeMoonshotAI);
+      });
+    });
+
+    describe('Bedrock AI provider', () => {
+      it('should initialize correctly with payload apiKey', async () => {
+        const jwtPayload: LobeBedrockAIParams = {
+          accessKeyId: 'user-aws-id',
+          accessKeySecret: 'user-aws-secret',
+          region: 'user-aws-region',
+        };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Bedrock, {
+          bedrock: jwtPayload,
+        });
+
+        // 假设 LobeBedrockAI 是 Bedrock 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobeBedrockAI);
+      });
+    });
+
+    describe('Ollama provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: JWTPayload = { endpoint: 'user-ollama-url' };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Ollama, {
+          ollama: jwtPayload,
+        });
+
+        // 假设 LobeOllamaAI 是 Ollama 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobeOllamaAI);
+      });
+    });
+
+    describe('Perplexity AI provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: JWTPayload = { apiKey: 'user-perplexity-key' };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Perplexity, {
+          perplexity: jwtPayload,
+        });
+
+        // 假设 LobePerplexityAI 是 Perplexity 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobePerplexityAI);
+      });
+    });
+
+    describe('Anthropic AI provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: JWTPayload = { apiKey: 'user-anthropic-key' };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Anthropic, {
+          anthropic: jwtPayload,
+        });
+
+        // 假设 LobeAnthropicAI 是 Anthropic 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobeAnthropicAI);
+      });
+    });
+
+    describe('Mistral AI provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: JWTPayload = { apiKey: 'user-mistral-key' };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.Mistral, {
+          mistral: jwtPayload,
+        });
+
+        // 假设 LobeMistralAI 是 Mistral 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobeMistralAI);
+      });
+    });
+
+    describe('OpenRouter AI provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: JWTPayload = { apiKey: 'user-openrouter-key' };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.OpenRouter, {
+          openrouter: jwtPayload,
+        });
+
+        // 假设 LobeOpenRouterAI 是 OpenRouter 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobeOpenRouterAI);
+      });
+    });
+
+    describe('Together AI provider', () => {
+      it('should initialize correctly', async () => {
+        const jwtPayload: JWTPayload = { apiKey: 'user-togetherai-key' };
+        const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.TogetherAI, {
+          togetherai: jwtPayload,
+        });
+
+        // 假设 LobeTogetherAI 是 TogetherAI 提供者的实现类
+        expect(runtime['_runtime']).toBeInstanceOf(LobeTogetherAI);
+      });
+    });
+  });
+
+  describe('AgentRuntime chat method', () => {
+    it('should run correctly', async () => {
+      const jwtPayload: JWTPayload = { apiKey: 'user-openai-key', endpoint: 'user-endpoint' };
+      const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.OpenAI, {
+        openai: jwtPayload,
+      });
+
+      const payload: ChatStreamPayload = {
+        messages: [{ role: 'user', content: 'Hello, world!' }],
+        model: 'text-davinci-002',
+        temperature: 0,
+      };
+
+      vi.spyOn(LobeOpenAI.prototype, 'chat').mockResolvedValue(new Response(''));
+
+      await runtime.chat(payload);
+    });
+    it('should handle options correctly', async () => {
+      const jwtPayload: JWTPayload = { apiKey: 'user-openai-key', endpoint: 'user-endpoint' };
+      const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.OpenAI, {
+        openai: jwtPayload,
+      });
+
+      const payload: ChatStreamPayload = {
+        messages: [{ role: 'user', content: 'Hello, world!' }],
+        model: 'text-davinci-002',
+        temperature: 0,
+      };
+
+      const options: AgentChatOptions = {
+        provider: 'openai',
+        trace: {
+          traceId: 'test-trace-id',
+          traceName: TraceNameMap.Conversation,
+          sessionId: 'test-session-id',
+          topicId: 'test-topic-id',
+          tags: [],
+          userId: 'test-user-id',
+        },
+      };
+
+      vi.spyOn(LobeOpenAI.prototype, 'chat').mockResolvedValue(new Response(''));
+
+      await runtime.chat(payload, createTraceOptions(payload, options));
+    });
+
+    describe('callback', async () => {
+      const jwtPayload: JWTPayload = { apiKey: 'user-openai-key', endpoint: 'user-endpoint' };
+      const runtime = await AgentRuntime.initializeWithProviderOptions(ModelProvider.OpenAI, {
+        openai: jwtPayload,
+      });
+
+      const payload: ChatStreamPayload = {
+        messages: [{ role: 'user', content: 'Hello, world!' }],
+        model: 'text-davinci-002',
+        temperature: 0,
+      };
+
+      const options: AgentChatOptions = {
+        provider: 'openai',
+        trace: {
+          traceId: 'test-trace-id',
+          traceName: TraceNameMap.Conversation,
+          sessionId: 'test-session-id',
+          topicId: 'test-topic-id',
+          tags: [],
+          userId: 'test-user-id',
+        },
+        enableTrace: true,
+      };
+
+      const updateMock = vi.fn();
+      beforeEach(() => {
+        vi.mocked(getServerConfig).mockReturnValue({
+          ENABLE_LANGFUSE: true,
+          LANGFUSE_PUBLIC_KEY: 'abc',
+          LANGFUSE_SECRET_KEY: 'DDD',
+        } as any);
+      });
+
+      it('should call experimental_onToolCall correctly', async () => {
+        // 使用 spyOn 模拟 chat 方法
+        vi.spyOn(LobeOpenAI.prototype, 'chat').mockImplementation(
+          async (payload, { callback }: any) => {
+            // 模拟 experimental_onToolCall 回调的触发
+            if (callback?.experimental_onToolCall) {
+              await callback.experimental_onToolCall();
+            }
+            return new Response('abc');
+          },
+        );
+        vi.spyOn(LangfuseTraceClient.prototype, 'update').mockImplementation(updateMock);
+
+        await runtime.chat(payload, createTraceOptions(payload, options));
+
+        expect(updateMock).toHaveBeenCalledWith({ tags: ['Tools Call'] });
+      });
+      it('should call onStart correctly', async () => {
+        vi.spyOn(LangfuseGenerationClient.prototype, 'update').mockImplementation(updateMock);
+        vi.spyOn(LobeOpenAI.prototype, 'chat').mockImplementation(
+          async (payload, { callback }: any) => {
+            if (callback?.onStart) {
+              callback.onStart();
+            }
+            return new Response('Success');
+          },
+        );
+
+        await runtime.chat(payload, createTraceOptions(payload, options));
+
+        // Verify onStart was called
+        expect(updateMock).toHaveBeenCalledWith({ completionStartTime: expect.any(Date) });
+      });
+
+      it('should call onCompletion correctly', async () => {
+        // Spy on the chat method and trigger onCompletion callback
+        vi.spyOn(LangfuseGenerationClient.prototype, 'update').mockImplementation(updateMock);
+        vi.spyOn(LobeOpenAI.prototype, 'chat').mockImplementation(
+          async (payload, { callback }: any) => {
+            if (callback?.onCompletion) {
+              await callback.onCompletion('Test completion');
+            }
+            return new Response('Success');
+          },
+        );
+
+        await runtime.chat(payload, createTraceOptions(payload, options));
+
+        // Verify onCompletion was called with expected output
+        expect(updateMock).toHaveBeenCalledWith({
+          endTime: expect.any(Date),
+          metadata: {
+            provider: 'openai',
+            tools: undefined,
+          },
+          output: 'Test completion',
+        });
+      });
+      it('should call onFinal correctly', async () => {
+        vi.spyOn(LobeOpenAI.prototype, 'chat').mockImplementation(
+          async (payload, { callback }: any) => {
+            if (callback?.onFinal) {
+              await callback.onFinal('Test completion');
+            }
+            return new Response('Success');
+          },
+        );
+        const shutdownAsyncMock = vi.fn();
+        vi.spyOn(Langfuse.prototype, 'shutdownAsync').mockImplementation(shutdownAsyncMock);
+
+        await runtime.chat(payload, createTraceOptions(payload, options));
+
+        // Verify onCompletion was called with expected output
+        expect(shutdownAsyncMock).toHaveBeenCalled();
+      });
+    });
+  });
+});

package/src/libs/agent-runtime/AgentRuntime.ts

@@ -0,0 +1,192 @@
+import { ClientOptions } from 'openai';
+
+import type { TracePayload } from '@/const/trace';
+
+import { LobeRuntimeAI } from './BaseAI';
+import { LobeAnthropicAI } from './anthropic';
+import { LobeAzureOpenAI } from './azureOpenai';
+import { LobeBedrockAI, LobeBedrockAIParams } from './bedrock';
+import { LobeGoogleAI } from './google';
+import { LobeGroq } from './groq';
+import { LobeMistralAI } from './mistral';
+import { LobeMoonshotAI } from './moonshot';
+import { LobeOllamaAI } from './ollama';
+import { LobeOpenAI } from './openai';
+import { LobeOpenRouterAI } from './openrouter';
+import { LobePerplexityAI } from './perplexity';
+import { LobeTogetherAI } from './togetherai';
+import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from './types';
+import { LobeZeroOneAI } from './zeroone';
+import { LobeZhipuAI } from './zhipu';
+
+export interface AgentChatOptions {
+  enableTrace?: boolean;
+  provider: string;
+  trace?: TracePayload;
+}
+
+class AgentRuntime {
+  private _runtime: LobeRuntimeAI;
+
+  constructor(runtime: LobeRuntimeAI) {
+    this._runtime = runtime;
+  }
+
+  /**
+   * Initiates a chat session with the agent.
+   *
+   * @param payload - The payload containing the chat stream data.
+   * @param options - Optional chat competition options.
+   * @returns A Promise that resolves to the chat response.
+   *
+   * @example - Use without trace
+   * ```ts
+   * const agentRuntime = await initializeWithClientStore(provider, payload);
+   * const data = payload as ChatStreamPayload;
+   * return await agentRuntime.chat(data);
+   * ```
+   *
+   * @example - Use Langfuse trace
+   * ```ts
+   * // ============  1. init chat model   ============ //
+   * const agentRuntime = await initAgentRuntimeWithUserPayload(provider, jwtPayload);
+   * // ============  2. create chat completion   ============ //
+   * const data = {
+   * // your trace options here
+   *  } as ChatStreamPayload;
+   * const tracePayload = getTracePayload(req);
+   * return await agentRuntime.chat(data, createTraceOptions(data, {
+   *   provider,
+   *   trace: tracePayload,
+   * }));
+   * ```
+   */
+  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
+    return this._runtime.chat(payload, options);
+  }
+
+  async models() {
+    return this._runtime.models?.();
+  }
+
+  /**
+   * @description Initialize the runtime with the provider and the options
+   * @param provider choose a model provider
+   * @param params options of the choosed provider
+   * @returns the runtime instance
+   * Try to initialize the runtime with the provider and the options.
+   * @example
+   * ```ts
+   * const runtime = await AgentRuntime.initializeWithProviderOptions(provider, {
+   *    [provider]: {...options},
+   * })
+   * ```
+   * **Note**: If you try to get a AgentRuntime instance from client or server,
+   * you should use the methods to get the runtime instance at first.
+   * - `src/app/api/chat/agentRuntime.ts: initAgentRuntimeWithUserPayload` on server
+   * - `src/services/chat.ts: initializeWithClientStore` on client
+   */
+  static async initializeWithProviderOptions(
+    provider: string,
+    params: Partial<{
+      anthropic: Partial<ClientOptions>;
+      azure: { apiVersion?: string; apikey?: string; endpoint?: string };
+      bedrock: Partial<LobeBedrockAIParams>;
+      google: { apiKey?: string; baseURL?: string };
+      groq: Partial<ClientOptions>;
+      mistral: Partial<ClientOptions>;
+      moonshot: Partial<ClientOptions>;
+      ollama: Partial<ClientOptions>;
+      openai: Partial<ClientOptions>;
+      openrouter: Partial<ClientOptions>;
+      perplexity: Partial<ClientOptions>;
+      togetherai: Partial<ClientOptions>;
+      zeroone: Partial<ClientOptions>;
+      zhipu: Partial<ClientOptions>;
+    }>,
+  ) {
+    let runtimeModel: LobeRuntimeAI;
+
+    switch (provider) {
+      default:
+      case ModelProvider.OpenAI: {
+        // Will use the openai as default provider
+        runtimeModel = new LobeOpenAI(params.openai ?? (params as any)[provider]);
+        break;
+      }
+
+      case ModelProvider.Azure: {
+        runtimeModel = new LobeAzureOpenAI(
+          params.azure?.endpoint,
+          params.azure?.apikey,
+          params.azure?.apiVersion,
+        );
+        break;
+      }
+
+      case ModelProvider.ZhiPu: {
+        runtimeModel = await LobeZhipuAI.fromAPIKey(params.zhipu ?? {});
+        break;
+      }
+
+      case ModelProvider.Google: {
+        runtimeModel = new LobeGoogleAI(params.google ?? {});
+        break;
+      }
+
+      case ModelProvider.Moonshot: {
+        runtimeModel = new LobeMoonshotAI(params.moonshot ?? {});
+        break;
+      }
+
+      case ModelProvider.Bedrock: {
+        runtimeModel = new LobeBedrockAI(params.bedrock ?? {});
+        break;
+      }
+
+      case ModelProvider.Ollama: {
+        runtimeModel = new LobeOllamaAI(params.ollama ?? {});
+        break;
+      }
+
+      case ModelProvider.Perplexity: {
+        runtimeModel = new LobePerplexityAI(params.perplexity ?? {});
+        break;
+      }
+
+      case ModelProvider.Anthropic: {
+        runtimeModel = new LobeAnthropicAI(params.anthropic ?? {});
+        break;
+      }
+
+      case ModelProvider.Mistral: {
+        runtimeModel = new LobeMistralAI(params.mistral ?? {});
+        break;
+      }
+
+      case ModelProvider.Groq: {
+        runtimeModel = new LobeGroq(params.groq ?? {});
+        break;
+      }
+
+      case ModelProvider.OpenRouter: {
+        runtimeModel = new LobeOpenRouterAI(params.openrouter ?? {});
+        break;
+      }
+
+      case ModelProvider.TogetherAI: {
+        runtimeModel = new LobeTogetherAI(params.togetherai ?? {});
+        break;
+      }
+
+      case ModelProvider.ZeroOne: {
+        runtimeModel = new LobeZeroOneAI(params.zeroone ?? {});
+        break;
+      }
+    }
+
+    return new AgentRuntime(runtimeModel);
+  }
+}
+
+export default AgentRuntime;

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

@@ -1,3 +1,4 @@
+export { default as AgentRuntime } from './AgentRuntime';
 export { LobeAnthropicAI } from './anthropic';
 export { LobeAzureOpenAI } from './azureOpenai';
 export * from './BaseAI';

package/src/libs/swr/index.ts

@@ -32,3 +32,12 @@ export const useActionSWR: SWRHook = (key, fetch, config) =>
     revalidateOnReconnect: false,
     ...config,
   });
+
+export interface SWRRefreshParams<T, A = (...args: any[]) => any> {
+  action: A;
+  optimisticData?: (data: T | undefined) => T;
+}
+
+export type SWRefreshMethod<T> = <A extends (...args: any[]) => Promise<any>>(
+  params?: SWRRefreshParams<T, A>,
+) => ReturnType<A>;

package/src/locales/default/setting.ts

@@ -76,6 +76,10 @@ export default {
         },
       },
     },
+    fetchOnClient: {
+      desc: '客户端请求模式将从浏览器直接发起会话请求，可提升响应速度',
+      title: '使用客户端请求模式',
+    },
     fetcher: {
       fetch: '获取模型列表',
       fetching: '正在获取模型列表...',