@lobehub/lobehub 2.0.0-next.50 → 2.0.0-next.52

package/packages/model-runtime/src/core/contextBuilders/openai.test.ts

@@ -150,6 +150,64 @@ describe('convertOpenAIMessages', () => {
 
     expect(Promise.all).toHaveBeenCalledTimes(2); // 一次用于消息数组，一次用于内容数组
   });
+
+  it('should filter out reasoning field from messages', async () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: 'Hello',
+        reasoning: { content: 'some reasoning', duration: 100 },
+      },
+      { role: 'user', content: 'Hi' },
+    ] as any;
+
+    const result = await convertOpenAIMessages(messages);
+
+    expect(result).toEqual([
+      { role: 'assistant', content: 'Hello' },
+      { role: 'user', content: 'Hi' },
+    ]);
+    // Ensure reasoning field is removed
+    expect((result[0] as any).reasoning).toBeUndefined();
+  });
+
+  it('should filter out reasoning_content field from messages', async () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: 'Hello',
+        reasoning_content: 'some reasoning content',
+      },
+      { role: 'user', content: 'Hi' },
+    ] as any;
+
+    const result = await convertOpenAIMessages(messages);
+
+    expect(result).toEqual([
+      { role: 'assistant', content: 'Hello' },
+      { role: 'user', content: 'Hi' },
+    ]);
+    // Ensure reasoning_content field is removed
+    expect((result[0] as any).reasoning_content).toBeUndefined();
+  });
+
+  it('should filter out both reasoning and reasoning_content fields from messages', async () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: 'Hello',
+        reasoning: { content: 'some reasoning', duration: 100 },
+        reasoning_content: 'some reasoning content',
+      },
+    ] as any;
+
+    const result = await convertOpenAIMessages(messages);
+
+    expect(result).toEqual([{ role: 'assistant', content: 'Hello' }]);
+    // Ensure both fields are removed
+    expect((result[0] as any).reasoning).toBeUndefined();
+    expect((result[0] as any).reasoning_content).toBeUndefined();
+  });
 });
 
 describe('convertOpenAIResponseInputs', () => {

package/packages/model-runtime/src/core/contextBuilders/openai.ts

@@ -26,17 +26,31 @@ export const convertMessageContent = async (
 
 export const convertOpenAIMessages = async (messages: OpenAI.ChatCompletionMessageParam[]) => {
   return (await Promise.all(
-    messages.map(async (message) => ({
-      ...message,
-      content:
-        typeof message.content === 'string'
-          ? message.content
-          : await Promise.all(
-              (message.content || []).map((c) =>
-                convertMessageContent(c as OpenAI.ChatCompletionContentPart),
+    messages.map(async (message) => {
+      const msg = message as any;
+
+      // Explicitly map only valid ChatCompletionMessageParam fields
+      // Exclude reasoning and reasoning_content fields as they should not be sent in requests
+      const result: any = {
+        content:
+          typeof message.content === 'string'
+            ? message.content
+            : await Promise.all(
+                (message.content || []).map((c) =>
+                  convertMessageContent(c as OpenAI.ChatCompletionContentPart),
+                ),
               ),
-            ),
-    })),
+        role: msg.role,
+      };
+
+      // Add optional fields if they exist
+      if (msg.name !== undefined) result.name = msg.name;
+      if (msg.tool_calls !== undefined) result.tool_calls = msg.tool_calls;
+      if (msg.tool_call_id !== undefined) result.tool_call_id = msg.tool_call_id;
+      if (msg.function_call !== undefined) result.function_call = msg.function_call;
+
+      return result;
+    }),
   )) as OpenAI.ChatCompletionMessageParam[];
 };
 

package/packages/model-runtime/src/core/openaiCompatibleFactory/index.ts

@@ -766,12 +766,12 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
 
       const inputStartAt = Date.now();
 
-      const { messages, reasoning_effort, tools, reasoning, responseMode, ...res } =
+      const { messages, reasoning_effort, tools, reasoning, responseMode, max_tokens, ...res } =
         responses?.handlePayload
           ? (responses?.handlePayload(payload, this._options) as ChatStreamPayload)
           : payload;
 
-      // remove penalty params
+      // remove penalty params and chat completion specific params
       delete res.apiMode;
       delete res.frequency_penalty;
       delete res.presence_penalty;
@@ -797,6 +797,7 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
             }
           : {}),
         input,
+        ...(max_tokens && { max_output_tokens: max_tokens }),
         store: false,
         stream: !isStreaming ? undefined : isStreaming,
         tools: tools?.map((tool) => this.convertChatCompletionToolToResponseTool(tool)),

package/packages/model-runtime/src/providers/openai/index.test.ts

@@ -409,6 +409,50 @@ describe('LobeOpenAI', () => {
       const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
       expect(createCall.reasoning).toEqual({ effort: 'high', summary: 'auto' });
     });
+
+    it('should convert max_tokens to max_output_tokens for responses API', async () => {
+      const payload = {
+        max_tokens: 2048,
+        messages: [{ content: 'Hello', role: 'user' as const }],
+        model: 'o1-pro',
+        temperature: 0.7,
+      };
+
+      await instance.chat(payload);
+
+      const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
+      expect(createCall.max_output_tokens).toBe(2048);
+      expect(createCall.max_tokens).toBeUndefined();
+    });
+
+    it('should not include max_output_tokens when max_tokens is undefined', async () => {
+      const payload = {
+        messages: [{ content: 'Hello', role: 'user' as const }],
+        model: 'o1-pro',
+        temperature: 0.7,
+      };
+
+      await instance.chat(payload);
+
+      const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
+      expect(createCall.max_output_tokens).toBeUndefined();
+    });
+
+    it('should convert max_tokens to max_output_tokens for search-enabled models', async () => {
+      const payload = {
+        enabledSearch: true,
+        max_tokens: 4096,
+        messages: [{ content: 'Hello', role: 'user' as const }],
+        model: 'gpt-4o',
+        temperature: 0.7,
+      };
+
+      await instance.chat(payload);
+
+      const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
+      expect(createCall.max_output_tokens).toBe(4096);
+      expect(createCall.max_tokens).toBeUndefined();
+    });
   });
 
   describe('supportsFlexTier', () => {

package/packages/model-runtime/src/providers/wenxin/index.ts

@@ -4,12 +4,17 @@ import {
   OpenAICompatibleFactoryOptions,
   createOpenAICompatibleRuntime,
 } from '../../core/openaiCompatibleFactory';
+import { processMultiProviderModelList } from '../../utils/modelParse';
+
+export interface WenxinModelCard {
+  id: string;
+}
 
 export const params = {
   baseURL: 'https://qianfan.baidubce.com/v2',
   chatCompletion: {
     handlePayload: (payload) => {
-      const { enabledSearch, ...rest } = payload;
+      const { enabledSearch, thinking, ...rest } = payload;
 
       return {
         ...rest,
@@ -21,12 +26,28 @@ export const params = {
             enable_trace: true,
           },
         }),
+        ...(thinking && {
+          enable_thinking: { disabled: false, enabled: true }[thinking.type],
+          ...(thinking?.budget_tokens !== 0 && {
+            thinking_budget: Math.min(Math.max(thinking?.budget_tokens, 100), 16_384),
+          }),
+        }),
       } as any;
     },
   },
   debug: {
     chatCompletion: () => process.env.DEBUG_WENXIN_CHAT_COMPLETION === '1',
   },
+  models: async ({ client }) => {
+    const modelsPage = (await client.models.list()) as any;
+    const modelList: WenxinModelCard[] = modelsPage.data;
+
+    const standardModelList = modelList.map((model) => ({
+      id: model.id,
+    }));
+
+    return processMultiProviderModelList(standardModelList, 'wenxin');
+  },
   provider: ModelProvider.Wenxin,
 } satisfies OpenAICompatibleFactoryOptions;
 

package/packages/model-runtime/src/utils/modelParse.ts

@@ -98,6 +98,11 @@ export const MODEL_LIST_CONFIGS = {
     reasoningKeywords: ['thinking', 'seed', 'ui-tars'],
     visionKeywords: ['vision', '-m', 'seed', 'ui-tars'],
   },
+  wenxin: {
+    functionCallKeywords: ['ernie-5', 'ernie-x1', 'pro', 'ernie-4.5-21b-a3b-thinking'],
+    reasoningKeywords: ['thinking', 'ernie-x', 'ernie-4.5-vl-28b-a3b'],
+    visionKeywords: ['-vl', 'ernie-5.0', 'picocr', 'qianfan-composition'],
+  },
   xai: {
     functionCallKeywords: ['grok'],
     reasoningKeywords: ['mini', 'grok-4', 'grok-code-fast', '!non-reasoning'],
@@ -129,6 +134,7 @@ export const MODEL_OWNER_DETECTION_CONFIG = {
   qwen: ['qwen', 'qwq', 'qvq'],
   v0: ['v0'],
   volcengine: ['doubao'],
+  wenxin: ['ernie', 'qianfan'],
   xai: ['grok'],
   zeroone: ['yi-'],
   zhipu: ['glm'],

package/packages/types/src/tool/builtin.ts

@@ -115,7 +115,7 @@ export const LobeBuiltinToolSchema = z.object({
   type: z.literal('builtin'),
 });
 
-export interface BuiltinRenderProps<Content = any, Arguments = any, State = any> {
+export interface BuiltinRenderProps<Arguments = any, State = any, Content = any> {
   apiName?: string;
   args: Arguments;
   content: Content;
@@ -125,7 +125,9 @@ export interface BuiltinRenderProps<Content = any, Arguments = any, State = any>
   pluginState?: State;
 }
 
-export type BuiltinRender = <T = any>(props: BuiltinRenderProps<T>) => ReactNode;
+export type BuiltinRender = <A = any, S = any, C = any>(
+  props: BuiltinRenderProps<A, S, C>,
+) => ReactNode;
 
 export interface BuiltinPortalProps<Arguments = Record<string, any>, State = any> {
   apiName?: string;
@@ -137,9 +139,9 @@ export interface BuiltinPortalProps<Arguments = Record<string, any>, State = any
 
 export type BuiltinPortal = <T = any>(props: BuiltinPortalProps<T>) => ReactNode;
 
-export interface BuiltinPlaceholderProps {
+export interface BuiltinPlaceholderProps<T extends Record<string, any> = any> {
   apiName: string;
-  args?: Record<string, any>;
+  args?: T;
   identifier: string;
 }
 
@@ -151,3 +153,12 @@ export interface BuiltinServerRuntimeOutput {
   state?: any;
   success: boolean;
 }
+
+export interface BuiltinInterventionProps<Arguments = any> {
+  apiName?: string;
+  args: Arguments;
+  identifier?: string;
+  messageId: string;
+}
+
+export type BuiltinIntervention = (props: BuiltinInterventionProps) => ReactNode;

package/packages/types/src/tool/intervention.ts

@@ -5,9 +5,9 @@ import { z } from 'zod';
  */
 export type HumanInterventionPolicy =
   | 'never' // Never intervene, auto-execute
-  | 'require'; // Always require intervention
+  | 'required'; // Always require intervention
 
-export const HumanInterventionPolicySchema = z.enum(['never', 'require']);
+export const HumanInterventionPolicySchema = z.enum(['never', 'required']);
 
 /**
  * Argument Matcher for parameter-level filtering
@@ -116,6 +116,36 @@ export const HumanInterventionResponseSchema = z.object({
     .optional(),
 });
 
+/**
+ * User's global intervention configuration
+ * Applied across all tools in the session
+ */
+export interface UserInterventionConfig {
+  /**
+   * Allow list of approved tools (used in 'allow-list' mode)
+   * Format: "identifier/apiName"
+   *
+   * Examples:
+   * - "bash/bash"
+   * - "web-browsing/crawlSinglePage"
+   * - "search/search"
+   */
+  allowList?: string[];
+
+  /**
+   * Tool approval mode
+   * - auto-run: Automatically approve all tools without user consent
+   * - allow-list: Only approve tools in the allow list
+   * - manual: Use tool's own humanIntervention config (default)
+   */
+  approvalMode: 'auto-run' | 'allow-list' | 'manual';
+}
+
+export const UserInterventionConfigSchema = z.object({
+  allowList: z.array(z.string()).optional(),
+  approvalMode: z.enum(['auto-run', 'allow-list', 'manual']),
+});
+
 /**
  * Parameters for shouldIntervene method
  */

package/packages/types/src/user/settings/tool.ts

@@ -1,29 +1,5 @@
-export interface UserToolConfig {
-  /**
-   * Tool approval mode
-   * - auto-run: Automatically approve all tools without user consent
-   * - allow-list: Only approve tools in the allow list
-   * - manual: Require manual approval for each tool execution
-   */
-  approvalMode?: 'auto-run' | 'allow-list' | 'manual';
-
-  dalle: {
-    autoGenerate: boolean;
-  };
+import { UserInterventionConfig } from '../../tool';
 
-  /**
-   * Tool intervention configuration
-   */
-  humanIntervention?: {
-    /**
-     * Allow list of approved tools (used in 'allow-list' mode)
-     * Format: "identifier/apiName"
-     *
-     * Examples:
-     * - "web-browsing/crawlSinglePage"
-     * - "bash/bash"
-     * - "search/search"
-     */
-    allowList?: string[];
-  };
+export interface UserToolConfig {
+  humanIntervention?: UserInterventionConfig;
 }

package/src/config/modelProviders/wenxin.ts

@@ -1,13 +1,12 @@
 import { ModelProviderCard } from '@/types/llm';
 
-// ref https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Nlks5zkzu
 const BaiduWenxin: ModelProviderCard = {
   chatModels: [],
-  checkModel: 'ernie-speed-128k',
+  checkModel: 'ernie-4.5-turbo-latest',
   description:
     '企业级一站式大模型与AI原生应用开发及服务平台，提供最全面易用的生成式人工智能模型开发、应用开发全流程工具链',
   id: 'wenxin',
-  modelsUrl: 'https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Nlks5zkzu#%E5%AF%B9%E8%AF%9Dchat',
+  modelsUrl: 'https://console.bce.baidu.com/qianfan/modelcenter/model/buildIn/list',
   name: 'Wenxin',
   settings: {
     proxyUrl: {

package/src/features/Conversation/MarkdownElements/remarkPlugins/__snapshots__/createRemarkSelfClosingTagPlugin.test.ts.snap

@@ -1,5 +1,138 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
+exports[`createRemarkSelfClosingTagPlugin > should handle multiple tags in unordered list with directories and files 1`] = `
+{
+  "children": [
+    {
+      "children": [
+        {
+          "position": {
+            "end": {
+              "column": 32,
+              "line": 1,
+              "offset": 31,
+            },
+            "start": {
+              "column": 1,
+              "line": 1,
+              "offset": 0,
+            },
+          },
+          "type": "text",
+          "value": "我已查看了你桌面上 test 文件夹的目录，里面包含以下项目：",
+        },
+      ],
+      "position": {
+        "end": {
+          "column": 32,
+          "line": 1,
+          "offset": 31,
+        },
+        "start": {
+          "column": 1,
+          "line": 1,
+          "offset": 0,
+        },
+      },
+      "type": "paragraph",
+    },
+    {
+      "children": [
+        {
+          "checked": null,
+          "children": [
+            {
+              "data": {
+                "hName": "localFile",
+                "hProperties": {
+                  "isDirectory": true,
+                  "name": ".config",
+                  "path": "/Users/user/Desktop/test/.config",
+                },
+              },
+              "type": "localFile",
+            },
+          ],
+          "position": {
+            "end": {
+              "column": 87,
+              "line": 3,
+              "offset": 119,
+            },
+            "start": {
+              "column": 1,
+              "line": 3,
+              "offset": 33,
+            },
+          },
+          "spread": false,
+          "type": "listItem",
+        },
+        {
+          "checked": null,
+          "children": [
+            {
+              "data": {
+                "hName": "localFile",
+                "hProperties": {
+                  "isDirectory": true,
+                  "name": ".venv",
+                  "path": "/Users/user/Desktop/test/.venv",
+                },
+              },
+              "type": "localFile",
+            },
+          ],
+          "position": {
+            "end": {
+              "column": 79,
+              "line": 4,
+              "offset": 198,
+            },
+            "start": {
+              "column": 1,
+              "line": 4,
+              "offset": 120,
+            },
+          },
+          "spread": false,
+          "type": "listItem",
+        },
+      ],
+      "ordered": false,
+      "position": {
+        "end": {
+          "column": 79,
+          "line": 4,
+          "offset": 198,
+        },
+        "start": {
+          "column": 1,
+          "line": 3,
+          "offset": 33,
+        },
+      },
+      "spread": false,
+      "start": null,
+      "type": "list",
+    },
+  ],
+  "position": {
+    "end": {
+      "column": 79,
+      "line": 4,
+      "offset": 198,
+    },
+    "start": {
+      "column": 1,
+      "line": 1,
+      "offset": 0,
+    },
+  },
+  "type": "root",
+}
+`;
+
 exports[`createRemarkSelfClosingTagPlugin > should handle tag within a list item and generate snapshot 1`] = `
 {
   "children": [

package/src/features/Conversation/MarkdownElements/remarkPlugins/createRemarkSelfClosingTagPlugin.test.ts

@@ -201,4 +201,52 @@ describe('createRemarkSelfClosingTagPlugin', () => {
     const tree = processMarkdown(markdown, tagName);
     expect(tree).toMatchSnapshot();
   });
+
+  it('should handle multiple tags in unordered list with directories and files', () => {
+    const markdown = [
+      '我已查看了你桌面上 test 文件夹的目录，里面包含以下项目：',
+      '',
+      '- <localFile name=".config" path="/Users/user/Desktop/test/.config" isDirectory />    ', // 注意：行尾有 4 个空格
+      '- <localFile name=".venv" path="/Users/user/Desktop/test/.venv" isDirectory />',
+    ].join('\n');
+    const tree = processMarkdown(markdown, tagName);
+
+    // Should have 2 children: a paragraph and a list
+    expect(tree.children).toHaveLength(2);
+
+    // First child should be the introductory paragraph
+    expect(tree.children[0].type).toBe('paragraph');
+
+    // Second child should be the unordered list
+    const listNode = tree.children[1];
+    expect(listNode.type).toBe('list');
+    expect(listNode.ordered).toBe(false);
+
+    // The list should have 2 items
+    expect(listNode.children).toHaveLength(2);
+
+    // Verify first item (.config directory) - this one has trailing spaces after />
+    // When a tag is standalone in a list item, remark doesn't wrap it in a paragraph
+    const firstItem = listNode.children[0];
+    expect(firstItem.type).toBe('listItem');
+    const firstTag = firstItem.children[0];
+    expect(firstTag.type).toBe(tagName);
+    expect(firstTag.data?.hProperties).toEqual({
+      name: '.config',
+      path: '/Users/user/Desktop/test/.config',
+      isDirectory: true,
+    });
+
+    // Verify second item (.venv directory)
+    const secondItem = listNode.children[1];
+    const secondTag = secondItem.children[0];
+    expect(secondTag.type).toBe(tagName);
+    expect(secondTag.data?.hProperties).toEqual({
+      name: '.venv',
+      path: '/Users/user/Desktop/test/.venv',
+      isDirectory: true,
+    });
+
+    expect(tree).toMatchSnapshot();
+  });
 });

package/src/features/Conversation/MarkdownElements/remarkPlugins/createRemarkSelfClosingTagPlugin.ts

@@ -25,7 +25,8 @@ export const createRemarkSelfClosingTagPlugin =
   (tagName: string): Plugin<[], any> =>
   () => {
     // Regex for the specific tag, ensure it matches the entire string for HTML check
-    const exactTagRegex = new RegExp(`^<${tagName}(\\s+[^>]*?)?\\s*\\/>$`);
+    // Allow trailing whitespace after /> to handle cases where markdown parsers include it
+    const exactTagRegex = new RegExp(`^<${tagName}(\\s+[^>]*?)?\\s*\\/>\\s*$`);
     // Regex for finding tags within text
     const textTagRegex = new RegExp(`<${tagName}(\\s+[^>]*?)?\\s*\\/>`, 'g');
 

package/src/features/Conversation/Messages/Assistant/Tool/Render/LoadingPlaceholder/index.tsx

@@ -1,7 +1,7 @@
 import { safeParseJSON } from '@lobechat/utils';
 import { memo } from 'react';
 
-import { BuiltinToolPlaceholders } from '@/tools/placeholders';
+import { getBuiltinPlaceholder } from '@/tools/placeholders';
 
 import Arguments from '../Arguments';
 
@@ -14,9 +14,9 @@ interface LoadingPlaceholderProps {
 
 const LoadingPlaceholder = memo<LoadingPlaceholderProps>(
   ({ identifier, requestArgs, apiName, loading }) => {
-    const Render = BuiltinToolPlaceholders[identifier || ''];
+    const Render = getBuiltinPlaceholder(identifier, apiName);
 
-    if (identifier && Render) {
+    if (Render) {
       return (
         <Render apiName={apiName} args={safeParseJSON(requestArgs) || {}} identifier={identifier} />
       );