feat: add thinking block UI and model detection, enhance chat features

- Add ThinkingBlock component for displaying reasoning process
- Add model detection utility for provider-specific features
- Enhance OpenAI service with reasoning support
- Update store to manage thinking states
- Improve command and input handling
- Update UI components for better message display

Author: huzijie.sea

.blade/settings.local.json

@@ -1,7 +1,9 @@
 {
   "permissions": {
     "allow": [
-      "TestTool"
+      "TestTool",
+      "Bash(git status)",
+      "Bash(git diff *)"
     ],
     "ask": [],
     "deny": []

src/agent/Agent.ts

@@ -669,6 +669,11 @@ IMPORTANT: Execute according to the approved plan above. Follow the steps exactl
         logger.debug('当前权限模式:', context.permissionMode);
         logger.debug('================================\n');
 
+        // 🆕 如果 LLM 返回了 thinking 内容（DeepSeek R1 等），通知 UI
+        if (turnResult.reasoningContent && options?.onThinking) {
+          options.onThinking(turnResult.reasoningContent);
+        }
+
         // 🆕 如果 LLM 返回了 content，立即显示
         if (turnResult.content && turnResult.content.trim() && options?.onContent) {
           options.onContent(turnResult.content);

src/config/types.ts

@@ -61,6 +61,10 @@ export interface ModelConfig {
   maxContextTokens?: number; // 上下文窗口大小
   topP?: number;
   topK?: number;
+
+  // Thinking 模型配置（如 DeepSeek R1）
+  supportsThinking?: boolean; // 手动覆盖自动检测结果
+  thinkingBudget?: number; // 思考 token 预算（可选）
 }
 
 export interface BladeConfig {

src/services/ChatServiceInterface.ts

@@ -41,11 +41,13 @@ export interface ChatConfig {
  */
 export interface ChatResponse {
   content: string;
+  reasoningContent?: string; // Thinking 模型的推理过程（如 DeepSeek R1）
   toolCalls?: ChatCompletionMessageToolCall[];
   usage?: {
     promptTokens: number;
     completionTokens: number;
     totalTokens: number;
+    reasoningTokens?: number; // Thinking 模型消耗的推理 tokens
   };
 }
 
@@ -54,6 +56,7 @@ export interface ChatResponse {
  */
 export interface StreamChunk {
   content?: string;
+  reasoningContent?: string; // Thinking 模型的推理过程片段
   // biome-ignore lint/suspicious/noExplicitAny: 不同 provider 的 tool call 类型不同
   toolCalls?: any[];
   finishReason?: string;

src/services/OpenAIChatService.ts

@@ -193,13 +193,26 @@ export class OpenAIChatService implements IChatService {
         (tc): tc is ChatCompletionMessageToolCall => tc.type === 'function'
       );
 
+      // 提取 reasoning_content（DeepSeek R1 等 thinking 模型的扩展字段）
+      const extendedMessage = choice.message as typeof choice.message & {
+        reasoning_content?: string;
+      };
+      const reasoningContent = extendedMessage.reasoning_content || undefined;
+
+      // 提取 reasoning_tokens（thinking 模型的扩展 usage 字段）
+      const extendedUsage = completion.usage as typeof completion.usage & {
+        reasoning_tokens?: number;
+      };
+
       const response = {
         content: choice.message.content || '',
+        reasoningContent,
         toolCalls: toolCalls,
         usage: {
           promptTokens: completion.usage?.prompt_tokens || 0,
           completionTokens: completion.usage?.completion_tokens || 0,
           totalTokens: completion.usage?.total_tokens || 0,
+          reasoningTokens: extendedUsage?.reasoning_tokens,
         },
       };
 
@@ -309,6 +322,7 @@ export class OpenAIChatService implements IChatService {
 
       let chunkCount = 0;
       let totalContent = '';
+      let totalReasoningContent = '';
       let toolCallsReceived = false;
 
       for await (const chunk of stream) {
@@ -326,10 +340,19 @@ export class OpenAIChatService implements IChatService {
           continue;
         }
 
+        // 提取 reasoning_content（DeepSeek R1 等 thinking 模型的扩展字段）
+        const extendedDelta = delta as typeof delta & {
+          reasoning_content?: string;
+        };
+
         if (delta.content) {
           totalContent += delta.content;
         }
 
+        if (extendedDelta.reasoning_content) {
+          totalReasoningContent += extendedDelta.reasoning_content;
+        }
+
         if (delta.tool_calls && !toolCallsReceived) {
           toolCallsReceived = true;
           _logger.debug('🔧 [ChatService] Tool calls detected in stream');
@@ -341,13 +364,15 @@ export class OpenAIChatService implements IChatService {
           _logger.debug('📊 [ChatService] Stream summary:', {
             totalChunks: chunkCount,
             totalContentLength: totalContent.length,
+            totalReasoningContentLength: totalReasoningContent.length,
             hadToolCalls: toolCallsReceived,
             duration: Date.now() - startTime + 'ms',
           });
         }
 
         yield {
           content: delta.content || undefined,
+          reasoningContent: extendedDelta.reasoning_content || undefined,
           toolCalls: delta.tool_calls,
           finishReason: finishReason || undefined,
         };

src/store/selectors/index.ts

@@ -342,3 +342,23 @@ export const useIsModal = (modal: ActiveModal) =>
  */
 export const useIsBusy = () =>
   useBladeStore((state) => state.session.isThinking || state.command.isProcessing);
+
+// ==================== Thinking 模式选择器 ====================
+
+/**
+ * 获取 Thinking 模式是否启用
+ */
+export const useThinkingModeEnabled = () =>
+  useBladeStore((state) => state.app.thinkingModeEnabled);
+
+/**
+ * 获取当前 Thinking 内容（流式接收中）
+ */
+export const useCurrentThinkingContent = () =>
+  useBladeStore((state) => state.session.currentThinkingContent);
+
+/**
+ * 获取 Thinking 内容是否展开
+ */
+export const useThinkingExpanded = () =>
+  useBladeStore((state) => state.session.thinkingExpanded);

src/store/slices/appSlice.ts

@@ -32,6 +32,7 @@ const initialAppState: AppState = {
   modelEditorTarget: null,
   todos: [],
   awaitingSecondCtrlC: false,
+  thinkingModeEnabled: false, // Thinking 模式默认关闭
 };
 
 /**
@@ -137,5 +138,25 @@ export const createAppSlice: StateCreator<BladeStore, [], [], AppSlice> = (set)
         app: { ...state.app, awaitingSecondCtrlC: awaiting },
       }));
     },
+
+    // ==================== Thinking 模式相关 actions ====================
+
+    /**
+     * 设置 Thinking 模式开关状态
+     */
+    setThinkingModeEnabled: (enabled: boolean) => {
+      set((state) => ({
+        app: { ...state.app, thinkingModeEnabled: enabled },
+      }));
+    },
+
+    /**
+     * 切换 Thinking 模式开关
+     */
+    toggleThinkingMode: () => {
+      set((state) => ({
+        app: { ...state.app, thinkingModeEnabled: !state.app.thinkingModeEnabled },
+      }));
+    },
   },
 });

src/store/slices/sessionSlice.ts

@@ -41,6 +41,8 @@ const initialSessionState: SessionState = {
   error: null,
   isActive: true,
   tokenUsage: { ...initialTokenUsage },
+  currentThinkingContent: null,
+  thinkingExpanded: false,
 };
 
 /**
@@ -83,13 +85,16 @@ export const createSessionSlice: StateCreator<
 
     /**
      * 添加助手消息
+     * @param content 消息内容
+     * @param thinkingContent 可选的 thinking 内容（如 DeepSeek R1 的推理过程）
      */
-    addAssistantMessage: (content: string) => {
+    addAssistantMessage: (content: string, thinkingContent?: string) => {
       const message: SessionMessage = {
         id: `assistant-${Date.now()}-${Math.random()}`,
         role: 'assistant',
         content,
         timestamp: Date.now(),
+        thinkingContent,
       };
       get().session.actions.addMessage(message);
     },
@@ -208,5 +213,50 @@ export const createSessionSlice: StateCreator<
         },
       }));
     },
+
+    // ==================== Thinking 相关 actions ====================
+
+    /**
+     * 设置当前 thinking 内容（用于流式接收）
+     */
+    setCurrentThinkingContent: (content: string | null) => {
+      set((state) => ({
+        session: { ...state.session, currentThinkingContent: content },
+      }));
+    },
+
+    /**
+     * 追加 thinking 内容（用于流式接收增量）
+     */
+    appendThinkingContent: (delta: string) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          currentThinkingContent:
+            (state.session.currentThinkingContent || '') + delta,
+        },
+      }));
+    },
+
+    /**
+     * 设置 thinking 内容是否展开
+     */
+    setThinkingExpanded: (expanded: boolean) => {
+      set((state) => ({
+        session: { ...state.session, thinkingExpanded: expanded },
+      }));
+    },
+
+    /**
+     * 切换 thinking 内容展开/折叠状态
+     */
+    toggleThinkingExpanded: () => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          thinkingExpanded: !state.session.thinkingExpanded,
+        },
+      }));
+    },
   },
 });

src/store/types.ts

@@ -40,6 +40,7 @@ export interface SessionMessage {
   content: string;
   timestamp: number;
   metadata?: Record<string, unknown> | ToolMessageMetadata;
+  thinkingContent?: string; // Thinking 模型的推理过程内容
 }
 
 /**
@@ -64,6 +65,8 @@ export interface SessionState {
   error: string | null;
   isActive: boolean;
   tokenUsage: TokenUsage; // Token 使用量统计
+  currentThinkingContent: string | null; // 当前正在接收的 thinking 内容（流式）
+  thinkingExpanded: boolean; // thinking 内容是否展开显示
 }
 
 /**
@@ -72,7 +75,7 @@ export interface SessionState {
 export interface SessionActions {
   addMessage: (message: SessionMessage) => void;
   addUserMessage: (content: string) => void;
-  addAssistantMessage: (content: string) => void;
+  addAssistantMessage: (content: string, thinkingContent?: string) => void;
   addToolMessage: (content: string, metadata?: ToolMessageMetadata) => void;
   setThinking: (isThinking: boolean) => void;
   setCompacting: (isCompacting: boolean) => void;
@@ -83,6 +86,11 @@ export interface SessionActions {
   restoreSession: (sessionId: string, messages: SessionMessage[]) => void;
   updateTokenUsage: (usage: Partial<TokenUsage>) => void;
   resetTokenUsage: () => void;
+  // Thinking 相关 actions
+  setCurrentThinkingContent: (content: string | null) => void;
+  appendThinkingContent: (delta: string) => void;
+  setThinkingExpanded: (expanded: boolean) => void;
+  toggleThinkingExpanded: () => void;
 }
 
 /**
@@ -155,6 +163,7 @@ export interface AppState {
   modelEditorTarget: ModelConfig | null;
   todos: TodoItem[];
   awaitingSecondCtrlC: boolean; // 是否等待第二次 Ctrl+C 退出
+  thinkingModeEnabled: boolean; // Thinking 模式是否启用（Tab 切换）
 }
 
 /**
@@ -170,6 +179,9 @@ export interface AppActions {
   setTodos: (todos: TodoItem[]) => void;
   updateTodo: (todo: TodoItem) => void;
   setAwaitingSecondCtrlC: (awaiting: boolean) => void;
+  // Thinking 模式相关
+  setThinkingModeEnabled: (enabled: boolean) => void;
+  toggleThinkingMode: () => void;
 }
 
 /**

src/ui/components/ChatStatusBar.tsx

@@ -10,7 +10,9 @@ import {
   useIsReady,
   useIsThinking,
   usePermissionMode,
+  useThinkingModeEnabled,
 } from '../../store/selectors/index.js';
+import { isThinkingModel } from '../../utils/modelDetection.js';
 import { useGitBranch } from '../hooks/useGitBranch.js';
 
 /**
@@ -32,6 +34,10 @@ export const ChatStatusBar: React.FC = React.memo(() => {
   const currentModel = useCurrentModel();
   const contextRemaining = useContextRemaining();
   const isCompacting = useIsCompacting();
+  const thinkingModeEnabled = useThinkingModeEnabled();
+
+  // 检查当前模型是否支持 thinking
+  const supportsThinking = currentModel ? isThinkingModel(currentModel) : false;
   // 渲染模式提示（仅非 DEFAULT 模式显示）
   const renderModeIndicator = () => {
     if (permissionMode === PermissionMode.DEFAULT) {
@@ -116,6 +122,17 @@ export const ChatStatusBar: React.FC = React.memo(() => {
           <Text color="red">⚠ API 密钥未配置</Text>
         ) : (
           <>
+            {/* Thinking 模式指示器（仅当模型支持时显示） */}
+            {supportsThinking && (
+              <>
+                {thinkingModeEnabled ? (
+                  <Text color="cyan">Thinking on</Text>
+                ) : (
+                  <Text color="gray">Tab:Thinking</Text>
+                )}
+                <Text color="gray">·</Text>
+              </>
+            )}
             {currentModel && <Text color="gray">{currentModel.model}</Text>}
             <Text color="gray">·</Text>
             {isCompacting ? (