@lobehub/lobehub 2.0.0-next.51 → 2.0.0-next.53

package/packages/model-bank/src/aiModels/qwen.ts

@@ -1016,6 +1016,71 @@ const qwenChatModels: AIChatModelCard[] = [
     id: 'qwen3-max',
     maxOutput: 65_536,
     organization: 'Qwen',
+    pricing: {
+      currency: 'CNY',
+      units: [
+        {
+          lookup: {
+            prices: {
+              '[0, 0.032]': 3.2 * 0.2,
+              '[0.032, 0.128]': 6.4 * 0.2,
+              '[0.128, infinity]': 9.6 * 0.2,
+            },
+            pricingParams: ['textInputRange'],
+          },
+          name: 'textInput_cacheRead',
+          strategy: 'lookup',
+          unit: 'millionTokens',
+        },
+        {
+          lookup: {
+            prices: {
+              '[0, 0.032]': 3.2,
+              '[0.032, 0.128]': 6.4,
+              '[0.128, infinity]': 9.6,
+            },
+            pricingParams: ['textInputRange'],
+          },
+          name: 'textInput',
+          strategy: 'lookup',
+          unit: 'millionTokens',
+        },
+        {
+          lookup: {
+            prices: {
+              '[0, 0.032]': 12.8,
+              '[0.032, 0.128]': 25.6,
+              '[0.128, infinity]': 38.4,
+            },
+            pricingParams: ['textInputRange'],
+          },
+          name: 'textOutput',
+          strategy: 'lookup',
+          unit: 'millionTokens',
+        },
+      ],
+    },
+    releasedAt: '2025-09-23',
+    settings: {
+      searchImpl: 'params',
+    },
+    type: 'chat',
+  },
+  {
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+      search: true,
+    },
+    config: {
+      deploymentName: 'qwen3-max-preview', // 其支持上下文缓存
+    },
+    contextWindowTokens: 262_144,
+    description: '通义千问系列效果最好的模型，适合复杂、多步骤的任务。预览版已支持思考。',
+    displayName: 'Qwen3 Max Preview',
+    id: 'qwen3-max-preview',
+    maxOutput: 65_536,
+    organization: 'Qwen',
     pricing: {
       currency: 'CNY',
       units: [
@@ -1060,8 +1125,9 @@ const qwenChatModels: AIChatModelCard[] = [
         },
       ],
     },
-    releasedAt: '2025-09-23',
+    releasedAt: '2025-10-30',
     settings: {
+      extendParams: ['enableReasoning', 'reasoningBudgetToken'],
       searchImpl: 'params',
     },
     type: 'chat',
@@ -1260,8 +1326,8 @@ const qwenChatModels: AIChatModelCard[] = [
   },
   {
     abilities: {
-      vision: true,
       reasoning: true,
+      vision: true,
     },
     contextWindowTokens: 131_072,
     description:
@@ -1287,7 +1353,8 @@ const qwenChatModels: AIChatModelCard[] = [
       vision: true,
     },
     contextWindowTokens: 131_072,
-    description: 'Qwen3 VL 30B 非思考模式（Instruct），面向普通指令跟随场景，保持较高的多模态理解与生成能力。',
+    description:
+      'Qwen3 VL 30B 非思考模式（Instruct），面向普通指令跟随场景，保持较高的多模态理解与生成能力。',
     displayName: 'Qwen3 VL 30B A3B Instruct',
     id: 'qwen3-vl-30b-a3b-instruct',
     maxOutput: 32_768,
@@ -1303,8 +1370,8 @@ const qwenChatModels: AIChatModelCard[] = [
   },
   {
     abilities: {
-      vision: true,
       reasoning: true,
+      vision: true,
     },
     contextWindowTokens: 131_072,
     description: 'Qwen3 VL 8B 思考模式，面向轻量级多模态推理与交互场景，保留长上下文理解能力。',
@@ -1342,11 +1409,12 @@ const qwenChatModels: AIChatModelCard[] = [
   },
   {
     abilities: {
-      vision: true,
       reasoning: true,
+      vision: true,
     },
     contextWindowTokens: 131_072,
-    description: 'Qwen3 VL 235B A22B 思考模式（开源版），针对高难度强推理与长视频理解场景，提供顶尖的视觉+文本推理能力。',
+    description:
+      'Qwen3 VL 235B A22B 思考模式（开源版），针对高难度强推理与长视频理解场景，提供顶尖的视觉+文本推理能力。',
     displayName: 'Qwen3 VL 235B A22B Thinking',
     id: 'qwen3-vl-235b-a22b-thinking',
     maxOutput: 32_768,
@@ -1368,7 +1436,8 @@ const qwenChatModels: AIChatModelCard[] = [
       vision: true,
     },
     contextWindowTokens: 131_072,
-    description: 'Qwen3 VL 235B A22B 非思考模式（Instruct），适用于非思考指令场景，保持强大的视觉理解能力。',
+    description:
+      'Qwen3 VL 235B A22B 非思考模式（Instruct），适用于非思考指令场景，保持强大的视觉理解能力。',
     displayName: 'Qwen3 VL 235B A22B Instruct',
     id: 'qwen3-vl-235b-a22b-instruct',
     maxOutput: 32_768,

package/packages/model-bank/src/types/aiModel.ts

@@ -234,6 +234,7 @@ export type ExtendParamsType =
   | 'disableContextCaching'
   | 'reasoningEffort'
   | 'gpt5ReasoningEffort'
+  | 'gpt5_1ReasoningEffort'
   | 'textVerbosity'
   | 'thinking'
   | 'thinkingBudget'

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/types/src/agent/chatConfig.ts

@@ -32,6 +32,7 @@ export interface LobeAgentChatConfig {
   reasoningBudgetToken?: number;
   reasoningEffort?: 'low' | 'medium' | 'high';
   gpt5ReasoningEffort?: 'minimal' | 'low' | 'medium' | 'high';
+  gpt5_1ReasoningEffort?: 'none' | 'low' | 'medium' | 'high';
   /**
    * 输出文本详细程度控制
    */
@@ -66,6 +67,7 @@ export interface LobeAgentChatConfig {
 
 export const AgentChatConfigSchema = z.object({
   autoCreateTopicThreshold: z.number().default(2),
+  disableContextCaching: z.boolean().optional(),
   displayMode: z.enum(['chat', 'docs']).optional(),
   enableAutoCreateTopic: z.boolean().optional(),
   enableCompressHistory: z.boolean().optional(),
@@ -74,8 +76,11 @@ export const AgentChatConfigSchema = z.object({
   enableReasoning: z.boolean().optional(),
   enableReasoningEffort: z.boolean().optional(),
   enableStreaming: z.boolean().optional(),
+  gpt5ReasoningEffort: z.enum(['minimal', 'low', 'medium', 'high']).optional(),
+  gpt5_1ReasoningEffort: z.enum(['none', 'low', 'medium', 'high']).optional(),
   historyCount: z.number().optional(),
   reasoningBudgetToken: z.number().optional(),
+  reasoningEffort: z.enum(['low', 'medium', 'high']).optional(),
   searchFCModel: z
     .object({
       model: z.string(),
@@ -84,4 +89,8 @@ export const AgentChatConfigSchema = z.object({
     .optional(),
   searchMode: z.enum(['off', 'on', 'auto']).optional(),
   textVerbosity: z.enum(['low', 'medium', 'high']).optional(),
+  thinking: z.enum(['disabled', 'auto', 'enabled']).optional(),
+  thinkingBudget: z.number().optional(),
+  urlContext: z.boolean().optional(),
+  useModelBuiltinSearch: z.boolean().optional(),
 });

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;
 }
 

package/src/app/[variants]/(main)/chat/components/WorkspaceLayout.tsx

@@ -1,3 +1,4 @@
+import { useTheme } from 'antd-style';
 import { Suspense, memo } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
@@ -18,30 +19,38 @@ interface WorkspaceLayoutProps {
   mobile?: boolean;
 }
 
-const DesktopWorkspace = memo(() => (
-  <>
-    <ChatHeaderDesktop />
-    <Flexbox
-      height={'100%'}
-      horizontal
-      style={{ overflow: 'hidden', position: 'relative' }}
-      width={'100%'}
-    >
-      <Flexbox height={'100%'} style={{ overflow: 'hidden', position: 'relative' }} width={'100%'}>
-        <ConversationArea mobile={false} />
+const DesktopWorkspace = memo(() => {
+  const theme = useTheme();
+
+  return (
+    <>
+      <ChatHeaderDesktop />
+      <Flexbox
+        height={'100%'}
+        horizontal
+        style={{ overflow: 'hidden', position: 'relative' }}
+        width={'100%'}
+      >
+        <Flexbox
+          height={'100%'}
+          style={{ background: theme.colorBgContainer, overflow: 'hidden', position: 'relative' }}
+          width={'100%'}
+        >
+          <ConversationArea mobile={false} />
+        </Flexbox>
+        <Portal>
+          <Suspense fallback={<BrandTextLoading />}>
+            <PortalPanel mobile={false} />
+          </Suspense>
+        </Portal>
+        <TopicPanel>
+          <TopicSidebar mobile={false} />
+        </TopicPanel>
       </Flexbox>
-      <Portal>
-        <Suspense fallback={<BrandTextLoading />}>
-          <PortalPanel mobile={false} />
-        </Suspense>
-      </Portal>
-      <TopicPanel>
-        <TopicSidebar mobile={false} />
-      </TopicPanel>
-    </Flexbox>
-    <MainInterfaceTracker />
-  </>
-));
+      <MainInterfaceTracker />
+    </>
+  );
+});
 
 DesktopWorkspace.displayName = 'DesktopWorkspace';
 

package/src/features/ChatInput/ActionBar/Model/ControlsForm.tsx

@@ -12,6 +12,7 @@ import { aiModelSelectors, useAiInfraStore } from '@/store/aiInfra';
 
 import ContextCachingSwitch from './ContextCachingSwitch';
 import GPT5ReasoningEffortSlider from './GPT5ReasoningEffortSlider';
+import GPT51ReasoningEffortSlider from './GPT51ReasoningEffortSlider';
 import ReasoningEffortSlider from './ReasoningEffortSlider';
 import ReasoningTokenSlider from './ReasoningTokenSlider';
 import TextVerbositySlider from './TextVerbositySlider';
@@ -119,6 +120,17 @@ const ControlsForm = memo(() => {
         paddingBottom: 0,
       },
     },
+    {
+      children: <GPT51ReasoningEffortSlider />,
+      desc: 'reasoning_effort',
+      label: t('extendParams.reasoningEffort.title'),
+      layout: 'horizontal',
+      minWidth: undefined,
+      name: 'gpt5_1ReasoningEffort',
+      style: {
+        paddingBottom: 0,
+      },
+    },
     {
       children: <TextVerbositySlider />,
       desc: 'text_verbosity',

package/src/features/ChatInput/ActionBar/Model/GPT51ReasoningEffortSlider.tsx

@@ -0,0 +1,58 @@
+import { Slider } from 'antd';
+import { memo, useCallback } from 'react';
+import { Flexbox } from 'react-layout-kit';
+
+import { useAgentStore } from '@/store/agent';
+import { agentChatConfigSelectors } from '@/store/agent/selectors';
+
+const GPT51ReasoningEffortSlider = memo(() => {
+  const [config, updateAgentChatConfig] = useAgentStore((s) => [
+    agentChatConfigSelectors.currentChatConfig(s),
+    s.updateAgentChatConfig,
+  ]);
+
+  const gpt5_1ReasoningEffort = config.gpt5_1ReasoningEffort || 'none'; // Default to 'none' if not set
+
+  const marks = {
+    0: 'none',
+    1: 'low',
+    2: 'medium',
+    3: 'high',
+  };
+
+  const effortValues = ['none', 'low', 'medium', 'high'];
+  const indexValue = effortValues.indexOf(gpt5_1ReasoningEffort);
+  const currentValue = indexValue === -1 ? 0 : indexValue;
+
+  const updateGPT51ReasoningEffort = useCallback(
+    (value: number) => {
+      const effort = effortValues[value] as 'none' | 'low' | 'medium' | 'high';
+      updateAgentChatConfig({ gpt5_1ReasoningEffort: effort });
+    },
+    [updateAgentChatConfig],
+  );
+
+  return (
+    <Flexbox
+      align={'center'}
+      gap={12}
+      horizontal
+      paddingInline={'0 20px'}
+      style={{ minWidth: 200, width: '100%' }}
+    >
+      <Flexbox flex={1}>
+        <Slider
+          marks={marks}
+          max={3}
+          min={0}
+          onChange={updateGPT51ReasoningEffort}
+          step={1}
+          tooltip={{ open: false }}
+          value={currentValue}
+        />
+      </Flexbox>
+    </Flexbox>
+  );
+});
+
+export default GPT51ReasoningEffortSlider;

package/src/features/ChatItem/components/MessageContent.tsx

@@ -13,6 +13,7 @@ import { useStyles } from '../style';
 import { ChatItemProps } from '../type';
 
 export interface MessageContentProps {
+  className?: string;
   disabled?: ChatItemProps['disabled'];
   editing?: ChatItemProps['editing'];
   id: string;
@@ -39,6 +40,7 @@ const MessageContent = memo<MessageContentProps>(
     onDoubleClick,
     markdownProps,
     disabled,
+    className,
   }) => {
     const { t } = useTranslation('common');
     const { cx, styles } = useStyles({ disabled, editing, placement, primary, variant });
@@ -81,7 +83,7 @@ const MessageContent = memo<MessageContentProps>(
 
     return (
       <Flexbox
-        className={cx(styles.message, editing && styles.editingContainer)}
+        className={cx(styles.message, editing && styles.editingContainer, className)}
         onDoubleClick={onDoubleClick}
       >
         {messageContent}

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} />
       );

package/src/features/Conversation/Messages/Group/Tool/Render/Intervention/ApprovalActions.tsx

@@ -28,10 +28,12 @@ const ApprovalActions = memo<ApprovalActionsProps>(
     const [approveLoading, setApproveLoading] = useState(false);
 
     const { assistantGroupId } = useGroupMessage();
-    const [approveToolIntervention, rejectToolIntervention] = useChatStore((s) => [
-      s.approveToolCalling,
-      s.rejectToolCalling,
-    ]);
+    const [approveToolIntervention, rejectToolIntervention, rejectAndContinueToolIntervention] =
+      useChatStore((s) => [
+        s.approveToolCalling,
+        s.rejectToolCalling,
+        s.rejectAndContinueToolCalling,
+      ]);
     const addToolToAllowList = useUserStore((s) => s.addToolToAllowList);
 
     const handleApprove = async (remember?: boolean) => {
@@ -58,6 +60,14 @@ const ApprovalActions = memo<ApprovalActionsProps>(
       setRejectReason('');
     };
 
+    const handleRejectAndContinue = async (reason?: string) => {
+      setRejectLoading(true);
+      await rejectAndContinueToolIntervention(messageId, reason);
+      setRejectLoading(false);
+      setRejectPopoverOpen(false);
+      setRejectReason('');
+    };
+
     return (
       <Flexbox gap={8} horizontal>
         <Popover
@@ -67,14 +77,25 @@ const ApprovalActions = memo<ApprovalActionsProps>(
               <Flexbox align={'center'} horizontal justify={'space-between'}>
                 <div>{t('tool.intervention.rejectTitle')}</div>
 
-                <Button
-                  loading={rejectLoading}
-                  onClick={() => handleReject(rejectReason)}
-                  size="small"
-                  type="primary"
-                >
-                  {t('confirm', { ns: 'common' })}
-                </Button>
+                <Space>
+                  <Button
+                    color={'default'}
+                    loading={rejectLoading}
+                    onClick={() => handleReject(rejectReason)}
+                    size="small"
+                    variant={'filled'}
+                  >
+                    {t('tool.intervention.rejectOnly')}
+                  </Button>
+                  <Button
+                    loading={rejectLoading}
+                    onClick={() => handleRejectAndContinue(rejectReason)}
+                    size="small"
+                    type="primary"
+                  >
+                    {t('tool.intervention.rejectAndContinue')}
+                  </Button>
+                </Space>
               </Flexbox>
               <Input.TextArea
                 autoFocus
@@ -95,7 +116,7 @@ const ApprovalActions = memo<ApprovalActionsProps>(
           placement="bottomRight"
           trigger="click"
         >
-          <Button size="small" type="default">
+          <Button color={'default'} size="small" variant={'filled'}>
             {t('tool.intervention.reject')}
           </Button>
         </Popover>