feat: prompt call tool support reason;perf: ai proxy doc (#3982)

* update schema * perf: ai proxy doc * feat: prompt call tool support reason
2025-07-23 21:13:50 +00:00 · 2025-03-05 14:11:52 +08:00
parent e1aa068858
commit 3e3f2165db
23 changed files with 508 additions and 298 deletions
--- a/packages/global/core/chat/adapt.ts
+++ b/packages/global/core/chat/adapt.ts
@@ -1,8 +1,11 @@
 import type {
+  AIChatItemValueItemType,
  ChatItemType,
  ChatItemValueItemType,
  RuntimeUserPromptType,
-  UserChatItemType
+  SystemChatItemValueItemType,
+  UserChatItemType,
+  UserChatItemValueItemType
 } from '../../core/chat/type.d';
 import { ChatFileTypeEnum, ChatItemValueTypeEnum, ChatRoleEnum } from '../../core/chat/constants';
 import type {
@@ -174,137 +177,24 @@ export const GPTMessages2Chats = (
 ): ChatItemType[] => {
  const chatMessages = messages
    .map((item) => {
-      const value: ChatItemType['value'] = [];
      const obj = GPT2Chat[item.role];

-      if (
-        obj === ChatRoleEnum.System &&
-        item.role === ChatCompletionRequestMessageRoleEnum.System
-      ) {
-        if (Array.isArray(item.content)) {
-          item.content.forEach((item) => [
-            value.push({
-              type: ChatItemValueTypeEnum.text,
-              text: {
-                content: item.text
-              }
-            })
-          ]);
-        } else {
-          value.push({
-            type: ChatItemValueTypeEnum.text,
-            text: {
-              content: item.content
-            }
-          });
-        }
-      } else if (
-        obj === ChatRoleEnum.Human &&
-        item.role === ChatCompletionRequestMessageRoleEnum.User
-      ) {
-        if (typeof item.content === 'string') {
-          value.push({
-            type: ChatItemValueTypeEnum.text,
-            text: {
-              content: item.content
-            }
-          });
-        } else if (Array.isArray(item.content)) {
-          item.content.forEach((item) => {
-            if (item.type === 'text') {
+      const value = (() => {
+        if (
+          obj === ChatRoleEnum.System &&
+          item.role === ChatCompletionRequestMessageRoleEnum.System
+        ) {
+          const value: SystemChatItemValueItemType[] = [];
+
+          if (Array.isArray(item.content)) {
+            item.content.forEach((item) => [
              value.push({
                type: ChatItemValueTypeEnum.text,
                text: {
                  content: item.text
                }
-              });
-            } else if (item.type === 'image_url') {
-              value.push({
-                //@ts-ignore
-                type: ChatItemValueTypeEnum.file,
-                file: {
-                  type: ChatFileTypeEnum.image,
-                  name: '',
-                  url: item.image_url.url
-                }
-              });
-            } else if (item.type === 'file_url') {
-              value.push({
-                // @ts-ignore
-                type: ChatItemValueTypeEnum.file,
-                file: {
-                  type: ChatFileTypeEnum.file,
-                  name: item.name,
-                  url: item.url
-                }
-              });
-            }
-          });
-        }
-      } else if (
-        obj === ChatRoleEnum.AI &&
-        item.role === ChatCompletionRequestMessageRoleEnum.Assistant
-      ) {
-        if (item.tool_calls && reserveTool) {
-          // save tool calls
-          const toolCalls = item.tool_calls as ChatCompletionMessageToolCall[];
-          value.push({
-            //@ts-ignore
-            type: ChatItemValueTypeEnum.tool,
-            tools: toolCalls.map((tool) => {
-              let toolResponse =
-                messages.find(
-                  (msg) =>
-                    msg.role === ChatCompletionRequestMessageRoleEnum.Tool &&
-                    msg.tool_call_id === tool.id
-                )?.content || '';
-              toolResponse =
-                typeof toolResponse === 'string' ? toolResponse : JSON.stringify(toolResponse);
-
-              return {
-                id: tool.id,
-                toolName: tool.toolName || '',
-                toolAvatar: tool.toolAvatar || '',
-                functionName: tool.function.name,
-                params: tool.function.arguments,
-                response: toolResponse as string
-              };
-            })
-          });
-        } else if (item.function_call && reserveTool) {
-          const functionCall = item.function_call as ChatCompletionMessageFunctionCall;
-          const functionResponse = messages.find(
-            (msg) =>
-              msg.role === ChatCompletionRequestMessageRoleEnum.Function &&
-              msg.name === item.function_call?.name
-          ) as ChatCompletionFunctionMessageParam;
-
-          if (functionResponse) {
-            value.push({
-              //@ts-ignore
-              type: ChatItemValueTypeEnum.tool,
-              tools: [
-                {
-                  id: functionCall.id || '',
-                  toolName: functionCall.toolName || '',
-                  toolAvatar: functionCall.toolAvatar || '',
-                  functionName: functionCall.name,
-                  params: functionCall.arguments,
-                  response: functionResponse.content || ''
-                }
-              ]
-            });
-          }
-        } else if (item.interactive) {
-          value.push({
-            //@ts-ignore
-            type: ChatItemValueTypeEnum.interactive,
-            interactive: item.interactive
-          });
-        } else if (typeof item.content === 'string') {
-          const lastValue = value[value.length - 1];
-          if (lastValue && lastValue.type === ChatItemValueTypeEnum.text && lastValue.text) {
-            lastValue.text.content += item.content;
+              })
+            ]);
          } else {
            value.push({
              type: ChatItemValueTypeEnum.text,
@@ -313,8 +203,145 @@ export const GPTMessages2Chats = (
              }
            });
          }
+          return value;
+        } else if (
+          obj === ChatRoleEnum.Human &&
+          item.role === ChatCompletionRequestMessageRoleEnum.User
+        ) {
+          const value: UserChatItemValueItemType[] = [];
+
+          if (typeof item.content === 'string') {
+            value.push({
+              type: ChatItemValueTypeEnum.text,
+              text: {
+                content: item.content
+              }
+            });
+          } else if (Array.isArray(item.content)) {
+            item.content.forEach((item) => {
+              if (item.type === 'text') {
+                value.push({
+                  type: ChatItemValueTypeEnum.text,
+                  text: {
+                    content: item.text
+                  }
+                });
+              } else if (item.type === 'image_url') {
+                value.push({
+                  //@ts-ignore
+                  type: ChatItemValueTypeEnum.file,
+                  file: {
+                    type: ChatFileTypeEnum.image,
+                    name: '',
+                    url: item.image_url.url
+                  }
+                });
+              } else if (item.type === 'file_url') {
+                value.push({
+                  // @ts-ignore
+                  type: ChatItemValueTypeEnum.file,
+                  file: {
+                    type: ChatFileTypeEnum.file,
+                    name: item.name,
+                    url: item.url
+                  }
+                });
+              }
+            });
+          }
+          return value;
+        } else if (
+          obj === ChatRoleEnum.AI &&
+          item.role === ChatCompletionRequestMessageRoleEnum.Assistant
+        ) {
+          const value: AIChatItemValueItemType[] = [];
+
+          if (typeof item.reasoning_text === 'string') {
+            value.push({
+              type: ChatItemValueTypeEnum.reasoning,
+              reasoning: {
+                content: item.reasoning_text
+              }
+            });
+          }
+          if (item.tool_calls && reserveTool) {
+            // save tool calls
+            const toolCalls = item.tool_calls as ChatCompletionMessageToolCall[];
+            value.push({
+              //@ts-ignore
+              type: ChatItemValueTypeEnum.tool,
+              tools: toolCalls.map((tool) => {
+                let toolResponse =
+                  messages.find(
+                    (msg) =>
+                      msg.role === ChatCompletionRequestMessageRoleEnum.Tool &&
+                      msg.tool_call_id === tool.id
+                  )?.content || '';
+                toolResponse =
+                  typeof toolResponse === 'string' ? toolResponse : JSON.stringify(toolResponse);
+
+                return {
+                  id: tool.id,
+                  toolName: tool.toolName || '',
+                  toolAvatar: tool.toolAvatar || '',
+                  functionName: tool.function.name,
+                  params: tool.function.arguments,
+                  response: toolResponse as string
+                };
+              })
+            });
+          }
+          if (item.function_call && reserveTool) {
+            const functionCall = item.function_call as ChatCompletionMessageFunctionCall;
+            const functionResponse = messages.find(
+              (msg) =>
+                msg.role === ChatCompletionRequestMessageRoleEnum.Function &&
+                msg.name === item.function_call?.name
+            ) as ChatCompletionFunctionMessageParam;
+
+            if (functionResponse) {
+              value.push({
+                //@ts-ignore
+                type: ChatItemValueTypeEnum.tool,
+                tools: [
+                  {
+                    id: functionCall.id || '',
+                    toolName: functionCall.toolName || '',
+                    toolAvatar: functionCall.toolAvatar || '',
+                    functionName: functionCall.name,
+                    params: functionCall.arguments,
+                    response: functionResponse.content || ''
+                  }
+                ]
+              });
+            }
+          }
+          if (item.interactive) {
+            value.push({
+              //@ts-ignore
+              type: ChatItemValueTypeEnum.interactive,
+              interactive: item.interactive
+            });
+          }
+          if (typeof item.content === 'string') {
+            const lastValue = value[value.length - 1];
+            if (lastValue && lastValue.type === ChatItemValueTypeEnum.text && lastValue.text) {
+              lastValue.text.content += item.content;
+            } else {
+              value.push({
+                type: ChatItemValueTypeEnum.text,
+                text: {
+                  content: item.content
+                }
+              });
+            }
+          }
+
+          return value;
        }
-      }
+
+        return [];
+      })();

      return {
        dataId: item.dataId,
--- a/packages/global/core/chat/type.d.ts
+++ b/packages/global/core/chat/type.d.ts
@@ -77,6 +77,7 @@ export type AIChatItemValueItemType = {
    | ChatItemValueTypeEnum.reasoning
    | ChatItemValueTypeEnum.tool
    | ChatItemValueTypeEnum.interactive;
+
  text?: {
    content: string;
  };
--- a/packages/global/core/workflow/template/system/aiChat/index.ts
+++ b/packages/global/core/workflow/template/system/aiChat/index.ts
@@ -55,7 +55,7 @@ export const AiChatModule: FlowNodeTemplateType = {
  showStatus: true,
  isTool: true,
  courseUrl: '/docs/guide/workbench/workflow/ai_chat/',
-  version: '4813',
+  version: '490',
  inputs: [
    Input_Template_SettingAiModel,
    // --- settings modal
--- a/packages/global/core/workflow/template/system/tools.ts
+++ b/packages/global/core/workflow/template/system/tools.ts
@@ -58,6 +58,13 @@ export const ToolModule: FlowNodeTemplateType = {
      valueType: WorkflowIOValueTypeEnum.boolean,
      value: true
    },
+    {
+      key: NodeInputKeyEnum.aiChatReasoning,
+      renderTypeList: [FlowNodeInputTypeEnum.hidden],
+      label: '',
+      valueType: WorkflowIOValueTypeEnum.boolean,
+      value: true
+    },
    {
      key: NodeInputKeyEnum.aiChatTopP,
      renderTypeList: [FlowNodeInputTypeEnum.hidden],
--- a/packages/service/common/file/read/utils.ts
+++ b/packages/service/common/file/read/utils.ts
@@ -245,7 +245,7 @@ export const readRawContentByFileBuffer = async ({
        if (result_data.data.status === 'success') {
          const result = result_data.data.result.pages
            .map((page) => page.md)
-            .join('\n')
+            .join('')
            // Do some post-processing
            .replace(/\\[\(\)]/g, '$')
            .replace(/\\[\[\]]/g, '$$')
--- a/packages/service/core/ai/config/provider/Moonshot.json
+++ b/packages/service/core/ai/config/provider/Moonshot.json
@@ -75,6 +75,81 @@
      "showTopP": true,
      "showStopSign": true,
      "responseFormatList": ["text", "json_object"]
+    },
+    {
+      "model": "moonshot-v1-8k-vision-preview",
+      "name": "moonshot-v1-8k-vision-preview",
+      "maxContext": 8000,
+      "maxResponse": 4000,
+      "quoteMaxToken": 6000,
+      "maxTemperature": 1,
+      "vision": true,
+      "toolChoice": true,
+      "functionCall": false,
+      "defaultSystemChatPrompt": "",
+      "datasetProcess": true,
+      "usedInClassify": true,
+      "customCQPrompt": "",
+      "usedInExtractFields": true,
+      "usedInQueryExtension": true,
+      "customExtractPrompt": "",
+      "usedInToolCall": true,
+      "defaultConfig": {},
+      "fieldMap": {},
+      "type": "llm",
+      "showTopP": true,
+      "showStopSign": true,
+      "responseFormatList": ["text", "json_object"]
+    },
+    {
+      "model": "moonshot-v1-32k-vision-preview",
+      "name": "moonshot-v1-32k-vision-preview",
+      "maxContext": 32000,
+      "maxResponse": 4000,
+      "quoteMaxToken": 32000,
+      "maxTemperature": 1,
+      "vision": true,
+      "toolChoice": true,
+      "functionCall": false,
+      "defaultSystemChatPrompt": "",
+      "datasetProcess": true,
+      "usedInClassify": true,
+      "customCQPrompt": "",
+      "usedInExtractFields": true,
+      "usedInQueryExtension": true,
+      "customExtractPrompt": "",
+      "usedInToolCall": true,
+      "defaultConfig": {},
+      "fieldMap": {},
+      "type": "llm",
+      "showTopP": true,
+      "showStopSign": true,
+      "responseFormatList": ["text", "json_object"]
+    },
+    {
+      "model": "moonshot-v1-128k-vision-preview",
+      "name": "moonshot-v1-128k-vision-preview",
+      "maxContext": 128000,
+      "maxResponse": 4000,
+      "quoteMaxToken": 60000,
+      "maxTemperature": 1,
+      "vision": true,
+      "toolChoice": true,
+      "functionCall": false,
+      "defaultSystemChatPrompt": "",
+      "datasetProcess": true,
+      "usedInClassify": true,
+      "customCQPrompt": "",
+      "usedInExtractFields": true,
+      "usedInQueryExtension": true,
+      "customExtractPrompt": "",
+      "usedInToolCall": true,
+      "defaultConfig": {},
+      "fieldMap": {},
+      "type": "llm",
+      "showTopP": true,
+      "showStopSign": true,
+      "responseFormatList": ["text", "json_object"]
    }
  ]
 }
--- a/packages/service/core/app/templates/templateSchema.ts
+++ b/packages/service/core/app/templates/templateSchema.ts
@@ -9,41 +9,23 @@ const AppTemplateSchema = new Schema({
    type: String,
    required: true
  },
-  name: {
-    type: String
-  },
-  intro: {
-    type: String
-  },
-  avatar: {
-    type: String
-  },
-  author: {
-    type: String
-  },
+  name: String,
+  intro: String,
+  avatar: String,
+  author: String,
  tags: {
    type: [String],
    default: undefined
  },
-  type: {
-    type: String
-  },
-  isActive: {
-    type: Boolean
-  },
-  userGuide: {
-    type: Object
-  },
-  isQuickTemplate: {
-    type: Boolean
-  },
+  type: String,
+  isActive: Boolean,
+  userGuide: Object,
+  isQuickTemplate: Boolean,
  order: {
    type: Number,
    default: -1
  },
-  workflow: {
-    type: Object
-  }
+  workflow: Object
 });

 AppTemplateSchema.index({ templateId: 1 });
--- a/packages/service/core/workflow/dispatch/agent/runTool/index.ts
+++ b/packages/service/core/workflow/dispatch/agent/runTool/index.ts
@@ -55,7 +55,8 @@ export const dispatchRunTools = async (props: DispatchToolModuleProps): Promise<
      userChatInput,
      history = 6,
      fileUrlList: fileLinks,
-      aiChatVision
+      aiChatVision,
+      aiChatReasoning
    }
  } = props;

@@ -63,6 +64,9 @@ export const dispatchRunTools = async (props: DispatchToolModuleProps): Promise<
  const useVision = aiChatVision && toolModel.vision;
  const chatHistories = getHistories(history, histories);

+  props.params.aiChatVision = aiChatVision && toolModel.vision;
+  props.params.aiChatReasoning = aiChatReasoning && toolModel.reasoning;
+
  const toolNodeIds = filterToolNodeIdByEdges({ nodeId, edges: runtimeEdges });

  // Gets the module to which the tool is connected
--- a/packages/service/core/workflow/dispatch/agent/runTool/promptCall.ts
+++ b/packages/service/core/workflow/dispatch/agent/runTool/promptCall.ts
@@ -24,7 +24,12 @@ import {
 import { AIChatItemType } from '@fastgpt/global/core/chat/type';
 import { GPTMessages2Chats } from '@fastgpt/global/core/chat/adapt';
 import { formatToolResponse, initToolCallEdges, initToolNodes } from './utils';
-import { computedMaxToken, llmCompletionsBodyFormat } from '../../../../ai/utils';
+import {
+  computedMaxToken,
+  llmCompletionsBodyFormat,
+  parseReasoningContent,
+  parseReasoningStreamContent
+} from '../../../../ai/utils';
 import { WorkflowResponseType } from '../../type';
 import { toolValueTypeList } from '@fastgpt/global/core/workflow/constants';
 import { WorkflowInteractiveResponseType } from '@fastgpt/global/core/workflow/template/system/interactive/type';
@@ -58,6 +63,7 @@ export const runToolWithPromptCall = async (
      temperature,
      maxToken,
      aiChatVision,
+      aiChatReasoning,
      aiChatTopP,
      aiChatStopSign,
      aiChatResponseFormat,
@@ -216,7 +222,7 @@ export const runToolWithPromptCall = async (
  const [requestMessages] = await Promise.all([
    loadRequestMessages({
      messages: filterMessages,
-      useVision: toolModel.vision && aiChatVision,
+      useVision: aiChatVision,
      origin: requestOrigin
    })
  ]);
@@ -251,22 +257,46 @@ export const runToolWithPromptCall = async (
    }
  });

-  const answer = await (async () => {
+  const { answer, reasoning } = await (async () => {
    if (res && isStreamResponse) {
-      const { answer } = await streamResponse({
+      const { answer, reasoning } = await streamResponse({
        res,
        toolNodes,
        stream: aiResponse,
-        workflowStreamResponse
+        workflowStreamResponse,
+        aiChatReasoning
      });

-      return answer;
+      return { answer, reasoning };
    } else {
-      const result = aiResponse as ChatCompletion;
+      const content = aiResponse.choices?.[0]?.message?.content || '';
+      const reasoningContent: string = aiResponse.choices?.[0]?.message?.reasoning_content || '';

-      return result.choices?.[0]?.message?.content || '';
+      // API already parse reasoning content
+      if (reasoningContent || !aiChatReasoning) {
+        return {
+          answer: content,
+          reasoning: reasoningContent
+        };
+      }
+
+      const [think, answer] = parseReasoningContent(content);
+      return {
+        answer,
+        reasoning: think
+      };
    }
  })();
+
+  if (stream && !isStreamResponse && aiChatReasoning && reasoning) {
+    workflowStreamResponse?.({
+      event: SseResponseEventEnum.fastAnswer,
+      data: textAdaptGptResponse({
+        reasoning_content: reasoning
+      })
+    });
+  }
+
  const { answer: replaceAnswer, toolJson } = parseAnswer(answer);
  if (!answer && !toolJson) {
    return Promise.reject(getEmptyResponseTip());
@@ -294,11 +324,16 @@ export const runToolWithPromptCall = async (
    }

    // No tool is invoked, indicating that the process is over
-    const gptAssistantResponse: ChatCompletionAssistantMessageParam = {
+    const gptAssistantResponse: ChatCompletionMessageParam = {
      role: ChatCompletionRequestMessageRoleEnum.Assistant,
-      content: replaceAnswer
+      content: replaceAnswer,
+      reasoning_text: reasoning
    };
-    const completeMessages = filterMessages.concat(gptAssistantResponse);
+    const completeMessages = filterMessages.concat({
+      ...gptAssistantResponse,
+      reasoning_text: undefined
+    });
+
    const inputTokens = await countGptMessagesTokens(requestMessages);
    const outputTokens = await countGptMessagesTokens([gptAssistantResponse]);

@@ -379,9 +414,10 @@ export const runToolWithPromptCall = async (
  })();

  // 合并工具调用的结果，使用 functionCall 格式存储。
-  const assistantToolMsgParams: ChatCompletionAssistantMessageParam = {
+  const assistantToolMsgParams: ChatCompletionMessageParam = {
    role: ChatCompletionRequestMessageRoleEnum.Assistant,
-    function_call: toolJson
+    function_call: toolJson,
+    reasoning_text: reasoning
  };

  // Only toolCall tokens are counted here, Tool response tokens count towards the next reply
@@ -502,12 +538,14 @@ ANSWER: `;
 async function streamResponse({
  res,
  stream,
-  workflowStreamResponse
+  workflowStreamResponse,
+  aiChatReasoning
 }: {
  res: NextApiResponse;
  toolNodes: ToolNodeItemType[];
  stream: StreamChatType;
  workflowStreamResponse?: WorkflowResponseType;
+  aiChatReasoning?: boolean;
 }) {
  const write = responseWriteController({
    res,
@@ -515,7 +553,9 @@ async function streamResponse({
  });

  let startResponseWrite = false;
-  let textAnswer = '';
+  let answer = '';
+  let reasoning = '';
+  const { parsePart, getStartTagBuffer } = parseReasoningStreamContent();

  for await (const part of stream) {
    if (res.closed) {
@@ -523,13 +563,21 @@ async function streamResponse({
      break;
    }

-    const responseChoice = part.choices?.[0]?.delta;
-    // console.log(responseChoice, '---===');
+    const [reasoningContent, content] = parsePart(part, aiChatReasoning);
+    answer += content;
+    reasoning += reasoningContent;

-    if (responseChoice?.content) {
-      const content = responseChoice?.content || '';
-      textAnswer += content;
+    if (aiChatReasoning && reasoningContent) {
+      workflowStreamResponse?.({
+        write,
+        event: SseResponseEventEnum.answer,
+        data: textAdaptGptResponse({
+          reasoning_content: reasoningContent
+        })
+      });
+    }

+    if (content) {
      if (startResponseWrite) {
        workflowStreamResponse?.({
          write,
@@ -538,18 +586,20 @@ async function streamResponse({
            text: content
          })
        });
-      } else if (textAnswer.length >= 3) {
-        textAnswer = textAnswer.trim();
-        if (textAnswer.startsWith('0')) {
+      } else if (answer.length >= 3) {
+        answer = answer.trimStart();
+        if (/0(:|：)/.test(answer)) {
          startResponseWrite = true;
+
          // find first : index
-          const firstIndex = textAnswer.indexOf(':');
-          textAnswer = textAnswer.substring(firstIndex + 1).trim();
+          const firstIndex =
+            answer.indexOf('0:') !== -1 ? answer.indexOf('0:') : answer.indexOf('0：');
+          answer = answer.substring(firstIndex + 2).trim();
          workflowStreamResponse?.({
            write,
            event: SseResponseEventEnum.answer,
            data: textAdaptGptResponse({
-              text: textAnswer
+              text: answer
            })
          });
        }
@@ -557,7 +607,23 @@ async function streamResponse({
    }
  }

-  return { answer: textAnswer.trim() };
+  if (answer === '') {
+    answer = getStartTagBuffer();
+    if (/0(:|：)/.test(answer)) {
+      // find first : index
+      const firstIndex = answer.indexOf('0:') !== -1 ? answer.indexOf('0:') : answer.indexOf('0：');
+      answer = answer.substring(firstIndex + 2).trim();
+      workflowStreamResponse?.({
+        write,
+        event: SseResponseEventEnum.answer,
+        data: textAdaptGptResponse({
+          text: answer
+        })
+      });
+    }
+  }
+
+  return { answer, reasoning };
 }

 const parseAnswer = (
@@ -568,8 +634,7 @@ const parseAnswer = (
 } => {
  str = str.trim();
  // 首先，使用正则表达式提取TOOL_ID和TOOL_ARGUMENTS
-  const prefixReg = /^1(:|：)/;
-  const answerPrefixReg = /^0(:|：)/;
+  const prefixReg = /1(:|：)/;

  if (prefixReg.test(str)) {
    const toolString = sliceJsonStr(str);
@@ -585,13 +650,21 @@ const parseAnswer = (
        }
      };
    } catch (error) {
-      return {
-        answer: ERROR_TEXT
-      };
+      if (/^1(:|：)/.test(str)) {
+        return {
+          answer: ERROR_TEXT
+        };
+      } else {
+        return {
+          answer: str
+        };
+      }
    }
  } else {
+    const firstIndex = str.indexOf('0:') !== -1 ? str.indexOf('0:') : str.indexOf('0：');
+    const answer = str.substring(firstIndex + 2).trim();
    return {
-      answer: str.replace(answerPrefixReg, '')
+      answer
    };
  }
 };
--- a/packages/service/core/workflow/dispatch/agent/runTool/type.d.ts
+++ b/packages/service/core/workflow/dispatch/agent/runTool/type.d.ts
@@ -22,6 +22,7 @@ export type DispatchToolModuleProps = ModuleDispatchProps<{
  [NodeInputKeyEnum.aiChatTemperature]: number;
  [NodeInputKeyEnum.aiChatMaxToken]: number;
  [NodeInputKeyEnum.aiChatVision]?: boolean;
+  [NodeInputKeyEnum.aiChatReasoning]?: boolean;
  [NodeInputKeyEnum.aiChatTopP]?: number;
  [NodeInputKeyEnum.aiChatStopSign]?: string;
  [NodeInputKeyEnum.aiChatResponseFormat]?: string;
--- a/packages/service/core/workflow/dispatch/chat/oneapi.ts
+++ b/packages/service/core/workflow/dispatch/chat/oneapi.ts
@@ -563,6 +563,15 @@ async function streamResponse({
  // if answer is empty, try to get value from startTagBuffer. (Cause: The response content is too short to exceed the minimum parse length)
  if (answer === '') {
    answer = getStartTagBuffer();
+    if (isResponseAnswerText && answer) {
+      workflowStreamResponse?.({
+        write,
+        event: SseResponseEventEnum.answer,
+        data: textAdaptGptResponse({
+          text: answer
+        })
+      });
+    }
  }

  return { answer, reasoning };
--- a/packages/service/worker/readFile/index.ts
+++ b/packages/service/worker/readFile/index.ts
@@ -27,7 +27,9 @@ parentPort?.on('message', async (props: ReadRawTextProps<Uint8Array>) => {
      case 'csv':
        return readCsvRawText(params);
      default:
-        return Promise.reject('Only support .txt, .md, .html, .pdf, .docx, pptx, .csv, .xlsx');
+        return Promise.reject(
+          `Only support .txt, .md, .html, .pdf, .docx, pptx, .csv, .xlsx. "${params.extension}" is not supported.`
+        );
    }
  };