Version 1.0.4 is released.

PythonnotJava · PythonnotJava · commit ab9c05d45396 · 2026-07-13T14:06:52.000+08:00
diff --git a/lib/core/llm/anthropic_client.dart b/lib/core/llm/anthropic_client.dart
@@ -335,10 +335,12 @@ class AnthropicClient implements LlmClient {
   }
 
   /// 解析 Anthropic SSE：content_block_delta(text) → ContentToken；
-  /// tool_use block 累积 input_json_delta；message_stop → StreamComplete。
+  /// thinking block → ReasoningToken；tool_use block 累积 input_json_delta；
+  /// message_stop → StreamComplete。
   Stream<StreamEvent> _parseSse(Stream<List<int>> rawStream) async* {
     String buffer = '';
     final contentBuf = StringBuffer();
+    final thinkingBuf = StringBuffer(); // 扩展思考内容
     String finishReason = 'stop';
 
     // index → 正在累积的 tool_use block
@@ -373,18 +375,28 @@ class AnthropicClient implements LlmClient {
                 name: (block['name'] ?? '').toString(),
               );
             }
+            // 注意：thinking block 在 start 时没有内容，在 delta 中传输
             break;
           case 'content_block_delta':
             final idx = json['index'] as int? ?? 0;
             final delta = json['delta'] as Map<String, dynamic>?;
             if (delta == null) break;
-            if (delta['type'] == 'text_delta') {
+
+            final deltaType = delta['type'] as String?;
+            if (deltaType == 'text_delta') {
               final text = (delta['text'] ?? '').toString();
               if (text.isNotEmpty) {
                 contentBuf.write(text);
                 yield ContentToken(text);
               }
-            } else if (delta['type'] == 'input_json_delta') {
+            } else if (deltaType == 'thinking_delta') {
+              // 扩展思考内容
+              final text = (delta['thinking'] ?? '').toString();
+              if (text.isNotEmpty) {
+                thinkingBuf.write(text);
+                yield ReasoningToken(text);
+              }
+            } else if (deltaType == 'input_json_delta') {
               toolBlocks[idx]?.argsBuf.write(delta['partial_json'] ?? '');
             }
             break;
@@ -395,7 +407,7 @@ class AnthropicClient implements LlmClient {
             }
             break;
           case 'message_stop':
-            yield _complete(contentBuf, toolBlocks, finishReason);
+            yield _complete(contentBuf, thinkingBuf, toolBlocks, finishReason);
             return;
           case 'error':
             final msg = json['error']?['message'] ?? 'Anthropic stream error';
@@ -405,7 +417,12 @@ class AnthropicClient implements LlmClient {
     }
 
     // 流未显式 message_stop：返回截断标记，上层不得当作正常完成。
-    final fallback = _complete(contentBuf, toolBlocks, finishReason);
+    final fallback = _complete(
+      contentBuf,
+      thinkingBuf,
+      toolBlocks,
+      finishReason,
+    );
     yield StreamComplete(
       content: fallback.content,
       reasoningContent: fallback.reasoningContent,
@@ -417,6 +434,7 @@ class AnthropicClient implements LlmClient {
 
   StreamComplete _complete(
     StringBuffer contentBuf,
+    StringBuffer thinkingBuf,
     Map<int, _AnthropicToolBlock> toolBlocks,
     String finishReason,
   ) {
@@ -426,6 +444,7 @@ class AnthropicClient implements LlmClient {
     }
     return StreamComplete(
       content: contentBuf.isEmpty ? null : contentBuf.toString(),
+      reasoningContent: thinkingBuf.isEmpty ? null : thinkingBuf.toString(),
       toolCalls: calls,
       finishReason: finishReason,
     );
diff --git a/lib/features/chat/chat_provider.dart b/lib/features/chat/chat_provider.dart
@@ -1012,9 +1012,17 @@ class ChatNotifier extends StateNotifier<ChatState> {
         );
         // 如果 streamingText 含有 DSML 标记（模型以文本形式输出的工具调用），
         // 说明这些内容已被解析为 tool_call，清除残留的标记文本
-        final cleanedStream = state.streamingText.contains('DSML')
+        var cleanedStream = state.streamingText.contains('DSML')
             ? ''
             : state.streamingText;
+
+        // 自动补全未闭合的 <thinking> 标签
+        // 某些模型在思考模式下调用工具时，会输出 <thinking> 但忘记闭合标签
+        if (cleanedStream.contains('<thinking>') &&
+            !cleanedStream.contains('</thinking>')) {
+          cleanedStream += '\n</thinking>';
+        }
+
         state = state.copyWith(
           streamingText: cleanedStream,
           activeToolCalls: [...state.activeToolCalls, toolCall],
diff --git a/lib/features/multi_agent/providers/multi_agent_provider.dart b/lib/features/multi_agent/providers/multi_agent_provider.dart
@@ -628,10 +628,11 @@ class MultiAgentNotifier extends StateNotifier<MultiAgentState> {
     );
 
     // 创建 Executor
-    // 注意: 多智能体全自动执行 (无权限中间件确认)，故保持目录边界沙箱
-    // (allowOutsideRoot 默认 false)，避免子智能体无确认地越界写/删。
+    // 多智能体协作模式下，解除目录边界限制以支持跨文件访问。
+    // 由于是 auto 模式（无权限中间件），所有操作自动执行。
     final executor = CombinedExecutor(
       projectRoot: state.workingDirectory ?? '',
+      allowOutsideRoot: true, // 允许跨工作目录访问
       mcpClients: {},
       mcpToolsCache: {},
     );
diff --git a/test/executor_cross_file_test.dart b/test/executor_cross_file_test.dart
@@ -0,0 +1,139 @@
+import 'dart:io';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:path/path.dart' as p;
+import 'package:remind_ai/core/memory/project_config.dart';
+import 'package:remind_ai/core/toolshell/executor.dart';
+
+/// 测试 auto 模式 + allowOutsideRoot 的跨文件访问
+void main() {
+  group('Executor 跨文件访问测试', () {
+    late Directory tempDir;
+    late Directory projectDir;
+    late Directory outsideDir;
+    late String testFilePath;
+
+    setUp(() async {
+      // 创建临时目录结构
+      tempDir = await Directory.systemTemp.createTemp('executor_test_');
+      projectDir = Directory(p.join(tempDir.path, 'project'));
+      outsideDir = Directory(p.join(tempDir.path, 'outside'));
+      await projectDir.create();
+      await outsideDir.create();
+
+      // 在项目外创建测试文件
+      testFilePath = p.join(outsideDir.path, 'test.txt');
+      await File(testFilePath).writeAsString('外部文件内容');
+    });
+
+    tearDown(() async {
+      await tempDir.delete(recursive: true);
+    });
+
+    test('allowOutsideRoot=false (默认) 应该拒绝跨文件访问', () async {
+      final executor = Executor(
+        projectRoot: projectDir.path,
+        permissionMode: PermissionMode.auto,
+        allowOutsideRoot: false, // 默认值
+      );
+
+      final result = await executor.run('toolshell_read', {
+        'path': testFilePath,
+      });
+
+      // 应该返回错误
+      expect(result, contains('路径越界'));
+    });
+
+    test('allowOutsideRoot=true 应该允许跨文件访问（绝对路径）', () async {
+      final executor = Executor(
+        projectRoot: projectDir.path,
+        permissionMode: PermissionMode.auto,
+        allowOutsideRoot: true, // 关键设置
+      );
+
+      final result = await executor.run('toolshell_read', {
+        'path': testFilePath,
+      });
+
+      print('读取结果: $result');
+
+      // 应该成功读取
+      expect(result, contains('外部文件内容'));
+      expect(result, contains('status'));
+      expect(result, contains('success'));
+    });
+
+    test('allowOutsideRoot=true 相对路径仍然相对 projectRoot', () async {
+      final executor = Executor(
+        projectRoot: projectDir.path,
+        permissionMode: PermissionMode.auto,
+        allowOutsideRoot: true,
+      );
+
+      // 在项目内创建文件
+      final insideFile = File(p.join(projectDir.path, 'inside.txt'));
+      await insideFile.writeAsString('项目内文件');
+
+      // 使用相对路径
+      final result = await executor.run('toolshell_read', {
+        'path': 'inside.txt', // 相对路径
+      });
+
+      print('相对路径读取结果: $result');
+
+      // 应该成功读取
+      expect(result, contains('项目内文件'));
+    });
+
+    test('auto 模式 + allowOutsideRoot=true 应该允许写入外部文件', () async {
+      final executor = Executor(
+        projectRoot: projectDir.path,
+        permissionMode: PermissionMode.auto,
+        allowOutsideRoot: true,
+      );
+
+      final outsideWritePath = p.join(outsideDir.path, 'write_test.txt');
+
+      final result = await executor.run('toolshell_write', {
+        'path': outsideWritePath,
+        'content': '写入外部内容',
+        'mode': 'create',
+      });
+
+      print('写入结果: $result');
+
+      // 应该成功写入
+      expect(result, contains('success'));
+
+      // 验证文件确实被创建
+      expect(await File(outsideWritePath).exists(), isTrue);
+      expect(await File(outsideWritePath).readAsString(), equals('写入外部内容'));
+    });
+
+    test('normal 模式即使 allowOutsideRoot=true 也需要权限确认', () async {
+      var permissionRequested = false;
+
+      final executor = Executor(
+        projectRoot: projectDir.path,
+        permissionMode: PermissionMode.normal, // 注意这里是 normal
+        allowOutsideRoot: true,
+        onPermissionRequest: (tool, args) async {
+          permissionRequested = true;
+          return false; // 拒绝
+        },
+      );
+
+      final result = await executor.run('toolshell_write', {
+        'path': p.join(outsideDir.path, 'blocked.txt'),
+        'content': '应该被拒绝',
+        'mode': 'create',
+      });
+
+      // 应该请求了权限
+      expect(permissionRequested, isTrue);
+
+      // 应该被拒绝
+      expect(result, contains('PERMISSION_DENIED'));
+    });
+  });
+}
