@lobehub/chat 0.156.1 → 0.157.0

package/src/store/chat/slices/plugin/action.ts

@@ -3,14 +3,14 @@ import { t } from 'i18next';
 import { Md5 } from 'ts-md5';
 import { StateCreator } from 'zustand/vanilla';
 
+import { LOADING_FLAT } from '@/const/message';
 import { PLUGIN_SCHEMA_API_MD5_PREFIX, PLUGIN_SCHEMA_SEPARATOR } from '@/const/plugin';
 import { chatService } from '@/services/chat';
 import { CreateMessageParams, messageService } from '@/services/message';
 import { ChatStore } from '@/store/chat/store';
 import { useToolStore } from '@/store/tool';
 import { pluginSelectors } from '@/store/tool/selectors';
-import { ChatPluginPayload } from '@/types/message';
-import { OpenAIToolCall } from '@/types/openai/functionCall';
+import { ChatToolPayload, MessageToolCall } from '@/types/message';
 import { setNamespace } from '@/utils/storeDebug';
 
 import { chatSelectors } from '../../slices/message/selectors';
@@ -24,13 +24,15 @@ export interface ChatPluginAction {
     content: string,
     triggerAiMessage?: boolean,
   ) => Promise<void>;
-  invokeBuiltinTool: (id: string, payload: ChatPluginPayload) => Promise<void>;
-  invokeDefaultTypePlugin: (id: string, payload: any) => Promise<void>;
-  invokeMarkdownTypePlugin: (id: string, payload: ChatPluginPayload) => Promise<void>;
-  invokeStandaloneTypePlugin: (id: string, payload: ChatPluginPayload) => Promise<void>;
-  runPluginApi: (id: string, payload: ChatPluginPayload) => Promise<string | undefined>;
-  triggerAIMessage: (id: string, traceId?: string) => Promise<void>;
-  triggerFunctionCall: (id: string) => Promise<void>;
+  internal_transformToolCalls: (toolCalls: MessageToolCall[]) => ChatToolPayload[];
+  invokeBuiltinTool: (id: string, payload: ChatToolPayload) => Promise<void>;
+  invokeDefaultTypePlugin: (id: string, payload: any) => Promise<string | undefined>;
+  invokeMarkdownTypePlugin: (id: string, payload: ChatToolPayload) => Promise<void>;
+  invokeStandaloneTypePlugin: (id: string, payload: ChatToolPayload) => Promise<void>;
+  runPluginApi: (id: string, payload: ChatToolPayload) => Promise<string | undefined>;
+  triggerAIMessage: (params: { parentId?: string; traceId?: string }) => Promise<void>;
+  triggerToolCalls: (id: string) => Promise<void>;
+
   updatePluginState: (id: string, key: string, value: any) => Promise<void>;
 }
 
@@ -58,7 +60,42 @@ export const chatPlugin: StateCreator<
 
     await internal_updateMessageContent(id, content);
 
-    if (triggerAiMessage) await triggerAIMessage(id);
+    if (triggerAiMessage) await triggerAIMessage({ parentId: id });
+  },
+
+  internal_transformToolCalls: (toolCalls) => {
+    return toolCalls
+      .map((toolCall): ChatToolPayload | null => {
+        let payload: ChatToolPayload;
+
+        const [identifier, apiName, type] = toolCall.function.name.split(PLUGIN_SCHEMA_SEPARATOR);
+
+        if (!apiName) return null;
+
+        payload = {
+          apiName,
+          arguments: toolCall.function.arguments,
+          id: toolCall.id,
+          identifier,
+          type: (type ?? 'default') as any,
+        };
+
+        // if the apiName is md5, try to find the correct apiName in the plugins
+        if (apiName.startsWith(PLUGIN_SCHEMA_API_MD5_PREFIX)) {
+          const md5 = apiName.replace(PLUGIN_SCHEMA_API_MD5_PREFIX, '');
+          const manifest = pluginSelectors.getPluginManifestById(identifier)(
+            useToolStore.getState(),
+          );
+
+          const api = manifest?.api.find((api) => Md5.hashStr(api.name).toString() === md5);
+          if (api) {
+            payload.apiName = api.name;
+          }
+        }
+
+        return payload;
+      })
+      .filter(Boolean) as ChatToolPayload[];
   },
 
   invokeBuiltinTool: async (id, payload) => {
@@ -94,14 +131,13 @@ export const chatPlugin: StateCreator<
   },
 
   invokeDefaultTypePlugin: async (id, payload) => {
-    const { runPluginApi, triggerAIMessage } = get();
+    const { runPluginApi } = get();
 
     const data = await runPluginApi(id, payload);
 
     if (!data) return;
-    const traceId = chatSelectors.getTraceIdByMessageId(id)(get());
 
-    await triggerAIMessage(id, traceId);
+    return data;
   },
 
   invokeMarkdownTypePlugin: async (id, payload) => {
@@ -175,95 +211,73 @@ export const chatPlugin: StateCreator<
     return data;
   },
 
-  triggerAIMessage: async (id, traceId) => {
+  triggerAIMessage: async ({ parentId, traceId }) => {
     const { internal_coreProcessMessage } = get();
     const chats = chatSelectors.currentChats(get());
-    await internal_coreProcessMessage(chats, id, { traceId });
+    await internal_coreProcessMessage(chats, parentId ?? chats.at(-1)!.id, { traceId });
   },
 
-  triggerFunctionCall: async (id) => {
-    const message = chatSelectors.getMessageById(id)(get());
-    if (!message) return;
+  triggerToolCalls: async (assistantId) => {
+    const message = chatSelectors.getMessageById(assistantId)(get());
+    if (!message || !message.tools) return;
 
     const {
       invokeDefaultTypePlugin,
       invokeMarkdownTypePlugin,
       invokeStandaloneTypePlugin,
       invokeBuiltinTool,
-      refreshMessages,
-      internal_resendMessage,
-      deleteMessage,
+      triggerAIMessage,
     } = get();
 
-    let payload = { apiName: '', identifier: '' } as ChatPluginPayload;
-
-    // 识别到内容是 function_call 的情况下
-    // 将 function_call 转换为 plugin request payload
-    if (message.content) {
-      const { tool_calls } = JSON.parse(message.content) as {
-        tool_calls: OpenAIToolCall[];
+    let shouldCreateMessage = false;
+    let latestToolId = '';
+    const messagePools = message.tools.map(async (payload) => {
+      const toolMessage: CreateMessageParams = {
+        content: LOADING_FLAT,
+        parentId: assistantId,
+        plugin: payload,
+        role: 'tool',
+        sessionId: get().activeId,
+        tool_call_id: payload.id,
+        topicId: get().activeTopicId, // if there is activeTopicId，then add it to topicId
       };
 
-      const function_call = tool_calls[0].function;
-
-      const [identifier, apiName, type] = function_call.name.split(PLUGIN_SCHEMA_SEPARATOR);
-
-      payload = {
-        apiName,
-        arguments: function_call.arguments,
-        identifier,
-        type: (type ?? 'default') as any,
-      };
-
-      // fix https://github.com/lobehub/lobe-chat/issues/1094, remove and retry after experiencing plugin illusion
-      if (!apiName) {
-        internal_resendMessage(id);
-        deleteMessage(id);
-        return;
-      }
-
-      // if the apiName is md5, try to find the correct apiName in the plugins
-      if (apiName.startsWith(PLUGIN_SCHEMA_API_MD5_PREFIX)) {
-        const md5 = apiName.replace(PLUGIN_SCHEMA_API_MD5_PREFIX, '');
-        const manifest = pluginSelectors.getPluginManifestById(identifier)(useToolStore.getState());
-
-        const api = manifest?.api.find((api) => Md5.hashStr(api.name).toString() === md5);
-        if (!api) return;
-        payload.apiName = api.name;
+      const id = await get().internal_createMessage(toolMessage);
+
+      switch (payload.type) {
+        case 'standalone': {
+          await invokeStandaloneTypePlugin(id, payload);
+          break;
+        }
+
+        case 'markdown': {
+          await invokeMarkdownTypePlugin(id, payload);
+          break;
+        }
+
+        case 'builtin': {
+          await invokeBuiltinTool(id, payload);
+          break;
+        }
+
+        default: {
+          const data = await invokeDefaultTypePlugin(id, payload);
+          if (data) {
+            shouldCreateMessage = true;
+            latestToolId = id;
+          }
+        }
       }
-    } else {
-      if (message.plugin) payload = message.plugin;
-    }
-
-    if (!payload.apiName) return;
-
-    await messageService.updateMessage(id, {
-      content: !!message.content ? '' : undefined,
-      plugin: payload,
-      role: 'function',
     });
-    await refreshMessages();
 
-    switch (payload.type) {
-      case 'standalone': {
-        await invokeStandaloneTypePlugin(id, payload);
-        break;
-      }
+    await Promise.all(messagePools);
 
-      case 'markdown': {
-        await invokeMarkdownTypePlugin(id, payload);
-        break;
-      }
+    // only default type tool calls should trigger AI message
+    if (!shouldCreateMessage) return;
 
-      case 'builtin': {
-        await invokeBuiltinTool(id, payload);
-        break;
-      }
+    const traceId = chatSelectors.getTraceIdByMessageId(latestToolId)(get());
 
-      default: {
-        await invokeDefaultTypePlugin(id, payload);
-      }
-    }
+    await triggerAIMessage({ traceId });
   },
 
   updatePluginState: async (id, key, value) => {

package/src/store/chat/slices/share/action.test.ts

@@ -85,7 +85,7 @@ describe('shareSlice actions', () => {
     it('should include plugin information when withPluginInfo is true', async () => {
       // 模拟带有插件信息的消息
       const pluginMessage = {
-        role: 'function',
+        role: 'tool',
         content: 'plugin content',
         plugin: {
           type: 'default',
@@ -118,7 +118,7 @@ describe('shareSlice actions', () => {
 
     it('should not include plugin information when withPluginInfo is false', async () => {
       const pluginMessage = {
-        role: 'function',
+        role: 'tool',
         content: 'plugin content',
         plugin: {
           type: 'default',
@@ -154,7 +154,7 @@ describe('shareSlice actions', () => {
         { role: 'user', content: 'user message', id: '1' },
         { role: 'assistant', content: 'assistant message', id: '2' },
         {
-          role: 'function',
+          role: 'tool',
           content: 'plugin content',
           plugin: {
             type: 'default',

package/src/store/chat/slices/share/action.ts

@@ -81,7 +81,7 @@ export const chatShare: StateCreator<ChatStore, [['zustand/devtools', never]], [
             draft.push({ from: 'gpt', value: i.content });
             break;
           }
-          case 'function': {
+          case 'tool': {
             if (withPluginInfo)
               draft.push(
                 PLUGIN_INFO({

package/src/store/chat/slices/topic/action.ts

@@ -134,8 +134,13 @@ export const chatTopic: StateCreator<
       onLoadingChange: (loading) => {
         internal_updateTopicLoading(topicId, loading);
       },
-      onMessageHandle: (x) => {
-        output += x;
+      onMessageHandle: (chunk) => {
+        switch (chunk.type) {
+          case 'text': {
+            output += chunk.text;
+          }
+        }
+
         updateTopicTitleInSummary(topicId, output);
       },
       params: await chainSummaryTitle(messages),

package/src/store/tool/selectors/tool.ts

@@ -1,35 +1,16 @@
 import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 import { uniqBy } from 'lodash-es';
-import { Md5 } from 'ts-md5';
 
-import { PLUGIN_SCHEMA_API_MD5_PREFIX, PLUGIN_SCHEMA_SEPARATOR } from '@/const/plugin';
 import { MetaData } from '@/types/meta';
 import { ChatCompletionTool } from '@/types/openai/chat';
 import { LobeToolMeta } from '@/types/tool/tool';
+import { genToolCallingName } from '@/utils/toolCall';
 
 import { pluginHelpers } from '../helpers';
 import { ToolStoreState } from '../initialState';
 import { builtinToolSelectors } from '../slices/builtin/selectors';
 import { pluginSelectors } from '../slices/plugin/selectors';
 
-const getAPIName = (identifier: string, name: string, type?: string) => {
-  const pluginType = type && type !== 'default' ? `${PLUGIN_SCHEMA_SEPARATOR + type}` : '';
-
-  // 将插件的 identifier 作为前缀，避免重复
-  let apiName = identifier + PLUGIN_SCHEMA_SEPARATOR + name + pluginType;
-
-  // OpenAI GPT function_call name can't be longer than 64 characters
-  // So we need to use md5 to shorten the name
-  // and then find the correct apiName in response by md5
-  if (apiName.length >= 64) {
-    const md5Content = PLUGIN_SCHEMA_API_MD5_PREFIX + Md5.hashStr(name).toString();
-
-    apiName = identifier + PLUGIN_SCHEMA_SEPARATOR + md5Content + pluginType;
-  }
-
-  return apiName;
-};
-
 const enabledSchema =
   (tools: string[] = []) =>
   (s: ToolStoreState): ChatCompletionTool[] => {
@@ -41,7 +22,7 @@ const enabledSchema =
       .flatMap((manifest) =>
         manifest.api.map((m) => ({
           description: m.description,
-          name: getAPIName(manifest.identifier, m.name, manifest.type),
+          name: genToolCallingName(manifest.identifier, m.name, manifest.type),
           parameters: m.parameters,
         })),
       );
@@ -67,9 +48,10 @@ const enabledSystemRoles =
 
         const methods = manifest.api
           .map((m) =>
-            [`#### ${getAPIName(manifest.identifier, m.name, manifest.type)}`, m.description].join(
-              '\n\n',
-            ),
+            [
+              `#### ${genToolCallingName(manifest.identifier, m.name, manifest.type)}`,
+              m.description,
+            ].join('\n\n'),
           )
           .join('\n\n');
 

package/src/store/tool/slices/builtin/action.test.ts

@@ -0,0 +1,90 @@
+import { act, renderHook } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { useToolStore } from '../../store';
+
+vi.mock('zustand/traditional');
+
+describe('createBuiltinToolSlice', () => {
+  describe('invokeBuiltinTool', () => {
+    it('should return if the tool is already loading', async () => {
+      // Given
+      const key = 'text2image';
+      const params = {};
+
+      const mockFn = vi.fn();
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        useToolStore.setState({
+          text2image: mockFn,
+        });
+      });
+
+      await act(async () => {
+        // When
+        const data = await result.current.invokeBuiltinTool(key, params);
+        expect(data).toBeUndefined();
+      });
+
+      // Then
+      expect(mockFn).toHaveBeenCalled();
+    });
+
+    it('should invoke the specified tool action and return the stringified result', async () => {
+      // Given
+      const key = 'text2image';
+
+      const mockFn = vi.fn();
+      const { result } = renderHook(() => useToolStore());
+
+      const params = {
+        prompts: ['test prompt'],
+        size: '512x512',
+        quality: 'standard',
+        style: 'vivid',
+      };
+
+      act(() => {
+        useToolStore.setState({
+          builtinToolLoading: { [key]: false },
+          text2image: mockFn,
+        });
+      });
+      // When
+      await act(async () => {
+        await result.current.invokeBuiltinTool(key, params);
+      });
+
+      expect(mockFn).toBeCalledWith({
+        prompts: ['test prompt'],
+        quality: 'standard',
+        size: '512x512',
+        style: 'vivid',
+      });
+    });
+  });
+
+  describe('text2image', () => {
+    it('should map the prompts to DallEImageItem objects', () => {
+      // When
+      const { result } = renderHook(() => useToolStore());
+
+      const data = result.current.text2image(
+        {
+          prompts: ['prompt1', 'prompt2'],
+          size: '1024x1024',
+          quality: 'standard',
+          style: 'vivid',
+        },
+        'a',
+      );
+
+      // Then
+      expect(data).toEqual([
+        { prompt: 'prompt1', quality: 'standard', size: '1024x1024', style: 'vivid' },
+        { prompt: 'prompt2', quality: 'standard', size: '1024x1024', style: 'vivid' },
+      ]);
+    });
+  });
+});

package/src/types/llm.ts

@@ -75,7 +75,7 @@ export interface LLMParams {
   top_p?: number;
 }
 
-export type LLMRoleType = 'user' | 'system' | 'assistant' | 'function';
+export type LLMRoleType = 'user' | 'system' | 'assistant' | 'tool';
 
 export interface LLMMessage {
   content: string;

package/src/types/message/index.ts

@@ -3,11 +3,12 @@ import { IPluginErrorType } from '@lobehub/chat-plugin-sdk';
 import { ILobeAgentRuntimeErrorType } from '@/libs/agent-runtime';
 import { ErrorType } from '@/types/fetch';
 
-import { LLMRoleType } from '../llm';
 import { BaseDataModel } from '../meta';
-import { ChatPluginPayload } from './tools';
+import { ChatPluginPayload, ChatToolPayload } from './tools';
 import { Translate } from './translate';
 
+export type MessageRoleType = 'user' | 'system' | 'assistant' | 'tool';
+
 /**
  * 聊天消息错误对象
  */
@@ -51,9 +52,10 @@ export interface ChatMessage extends BaseDataModel {
    * parent message id
    */
   parentId?: string;
-  plugin?: ChatPluginPayload;
 
+  plugin?: ChatPluginPayload;
   pluginState?: any;
+
   /**
    * quoted other message's id
    */
@@ -61,9 +63,12 @@ export interface ChatMessage extends BaseDataModel {
   /**
    * message role type
    */
-  role: LLMRoleType;
+  role: MessageRoleType;
   sessionId?: string;
 
+  tool_call_id?: string;
+  tools?: ChatToolPayload[];
+
   /**
    * 保存到主题的消息
    */

package/src/types/message/tools.ts

@@ -1,3 +1,6 @@
+import { DeepPartial } from 'utility-types';
+import { z } from 'zod';
+
 import { LobeToolRenderType } from '@/types/tool';
 
 export interface ChatPluginPayload {
@@ -6,3 +9,57 @@ export interface ChatPluginPayload {
   identifier: string;
   type: LobeToolRenderType;
 }
+
+export interface ChatToolPayload {
+  apiName: string;
+  arguments: string;
+  id: string;
+  identifier: string;
+  type: LobeToolRenderType;
+}
+
+/**
+ * The function that the model called.
+ */
+export interface ToolFunction {
+  /**
+   * The arguments to call the function with, as generated by the model in JSON
+   * format. Note that the model does not always generate valid JSON, and may
+   * hallucinate parameters not defined by your function schema. Validate the
+   * arguments in your code before calling your function.
+   */
+  arguments: string;
+
+  /**
+   * The name of the function to call.
+   */
+  name: string;
+}
+
+export interface MessageToolCall {
+  /**
+   * The function that the model called.
+   */
+  function: ToolFunction;
+
+  /**
+   * The ID of the tool call.
+   */
+  id: string;
+
+  /**
+   * The type of the tool. Currently, only `function` is supported.
+   */
+  type: 'function' | string;
+}
+
+export type MessageToolCallChunk = DeepPartial<MessageToolCall> & { index: number };
+
+export const MessageToolCallSchema = z.object({
+  function: z.object({
+    arguments: z.string(),
+    name: z.string(),
+  }),
+  id: z.string(),
+  type: z.string(),
+});

package/src/types/openai/chat.ts

@@ -1,4 +1,5 @@
 import { LLMRoleType } from '@/types/llm';
+import { MessageToolCall } from '@/types/message';
 
 import { OpenAIFunctionCall } from './functionCall';
 
@@ -23,6 +24,9 @@ export interface OpenAIChatMessage {
    */
   content: string | UserMessageContentPart[];
 
+  /**
+   * @deprecated
+   */
   function_call?: OpenAIFunctionCall;
   name?: string;
   /**
@@ -30,6 +34,8 @@ export interface OpenAIChatMessage {
    * @description 消息发送者的角色
    */
   role: LLMRoleType;
+  tool_call_id?: string;
+  tool_calls?: MessageToolCall[];
 }
 
 /**