auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/sdk/core/auto_coder_core.py

@@ -4,11 +4,12 @@ Auto-Coder SDK 核心封装类
 提供统一的查询接口，处理同步和异步调用。
 """
 
-from typing import AsyncIterator, Optional, Dict, Any, Iterator
+from typing import AsyncIterator, Optional, Dict, Any, Iterator, List
 import asyncio
 import os
 import time
 from concurrent.futures import ThreadPoolExecutor
+import json
 
 # Rich 渲染相关导入
 from rich.console import Console
@@ -18,10 +19,10 @@ from rich.syntax import Syntax
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from ..models.options import AutoCodeOptions
-from ..models.messages import Message
 from ..models.responses import StreamEvent, CodeModificationResult
 from ..exceptions import BridgeError
 from .bridge import AutoCoderBridge
+from autocoder.common.wrap_llm_hint.utils import extract_content_from_text, has_hint_in_text
 
 
 class AutoCoderCore:
@@ -59,7 +60,13 @@ class AutoCoderCore:
         """
         if not show_terminal:
             return
+        
+        # 如果输出格式是 JSON 相关，输出 JSON 格式
+        if self.options.output_format in ["json", "stream-json"]:
+            self._render_json_event(event)
+            return
             
+        # 原有的文本渲染逻辑保持不变
         try:
             # 处理新的事件类型（动态检查以避免导入依赖）
             event_class_name = type(event).__name__
@@ -94,8 +101,27 @@ class AutoCoderCore:
                 tool = getattr(event, 'tool', None)
                 if tool and 'AttemptCompletionTool' in type(tool).__name__:
                     return
-                    
+                
                 tool_name = type(tool).__name__ if tool else "Unknown Tool"
+                
+                # 特殊处理 ConversationMessageIds 工具 - 只显示 compacting 消息
+                if tool and tool_name in ['ConversationMessageIdsWriteTool', 'ConversationMessageIdsReadTool']:
+                    # 使用国际化的 compacting 消息
+                    try:
+                        from autocoder.common.auto_coder_lang import get_system_language
+                        lang = get_system_language()
+                        compacting_message = "compacting..." if lang == "en" else "压缩中..."
+                    except:
+                        compacting_message = "compacting..."
+                    
+                    self._console.print(Panel(
+                        f"[dim]{compacting_message}[/dim]", 
+                        title="🗜️ Compacting", 
+                        border_style="yellow", 
+                        title_align="left"
+                    ))
+                    return
+                    
                 try:
                     # 尝试使用 get_tool_display_message 函数
                     from autocoder.common.v2.agent.agentic_edit_types import get_tool_display_message
@@ -121,6 +147,10 @@ class AutoCoderCore:
                 tool_name = getattr(event, 'tool_name', 'Unknown')
                 if tool_name in ["AttemptCompletionTool", "PlanModeRespondTool"]:
                     return
+                
+                # 跳过 ConversationMessageIds 工具的结果显示 - 已由 compacting 消息处理
+                if tool_name in ["ConversationMessageIdsWriteTool", "ConversationMessageIdsReadTool"]:
+                    return
                     
                 result = getattr(event, 'result', None)
                 if result:
@@ -190,6 +220,76 @@ class AutoCoderCore:
                 if conversation_id:
                     self._console.print(f"[dim]Conversation ID: {conversation_id}[/dim]")
                 return
+                
+            elif 'PreCommitEvent' in event_class_name:
+                # event.commit_result 一定存在
+                commit_result = event.commit_result
+                success = commit_result.success if hasattr(commit_result, 'success') else False
+                message = commit_result.message if hasattr(commit_result, 'message') else 'Pre-commit operation completed'
+                
+                title = "✅ Pre-Commit Success" if success else "❌ Pre-Commit Failed"
+                border_style = "yellow" if success else "red"
+                
+                self._console.print(Panel(
+                    f"[bold]Status:[/bold] {'Success' if success else 'Failed'}\n[bold]Message:[/bold] {message}",
+                    title=title,
+                    border_style=border_style,
+                    title_align="left"
+                ))
+                return
+                
+            elif 'CommitEvent' in event_class_name:
+                # event.commit_result 一定存在
+                commit_result = event.commit_result
+                success = commit_result.success if hasattr(commit_result, 'success') else False
+                message = commit_result.message if hasattr(commit_result, 'message') else 'Commit operation completed'
+                commit_hash = commit_result.commit_hash if hasattr(commit_result, 'commit_hash') else ''
+                
+                title = "✅ Commit Success" if success else "❌ Commit Failed"
+                border_style = "green" if success else "red"
+                
+                content = f"[bold]Status:[/bold] {'Success' if success else 'Failed'}\n[bold]Message:[/bold] {message}"
+                if commit_hash:
+                    content += f"\n[bold]Commit Hash:[/bold] {commit_hash}"
+                
+                self._console.print(Panel(
+                    content,
+                    title=title,
+                    border_style=border_style,
+                    title_align="left"
+                ))
+                return
+                
+            elif 'PullRequestEvent' in event_class_name:
+                # event.pull_request_result 一定存在
+                pr_result = event.pull_request_result
+                success = pr_result.success if hasattr(pr_result, 'success') else False
+                pr_number = pr_result.pr_number if hasattr(pr_result, 'pr_number') else None
+                pr_url = pr_result.pr_url if hasattr(pr_result, 'pr_url') else ''
+                error_message = pr_result.error_message if hasattr(pr_result, 'error_message') else ''
+                platform = pr_result.platform if hasattr(pr_result, 'platform') else 'Unknown'
+                
+                title = "✅ Pull Request Created" if success else "❌ Pull Request Failed"
+                border_style = "cyan" if success else "red"
+                
+                if success:
+                    content = f"[bold]Status:[/bold] Success\n[bold]Platform:[/bold] {platform}"
+                    if pr_number:
+                        content += f"\n[bold]PR Number:[/bold] #{pr_number}"
+                    if pr_url:
+                        content += f"\n[bold]PR URL:[/bold] {pr_url}"
+                else:
+                    content = f"[bold]Status:[/bold] Failed\n[bold]Platform:[/bold] {platform}"
+                    if error_message:
+                        content += f"\n[bold]Error:[/bold] {error_message}"
+                
+                self._console.print(Panel(
+                    content,
+                    title=title,
+                    border_style=border_style,
+                    title_align="left"
+                ))
+                return
             
             # 处理旧格式的事件类型
             if event.event_type == "start":
@@ -215,17 +315,40 @@ class AutoCoderCore:
                         
             elif event.event_type == "tool_call":
                 tool_name = event.data.get("tool_name", "Unknown Tool")
-                tool_args = event.data.get("args", {})
-                display_content = self._format_tool_display(tool_name, tool_args)
-                self._console.print(Panel(
-                    display_content, 
-                    title=f"🛠️ Action: {tool_name}", 
-                    border_style="blue", 
-                    title_align="left"
-                ))
+                
+                # 特殊处理 ConversationMessageIds 工具 - 只显示 compacting 消息
+                if tool_name in ['ConversationMessageIdsWriteTool', 'ConversationMessageIdsReadTool']:
+                    # 使用国际化的 compacting 消息
+                    try:
+                        from autocoder.common.auto_coder_lang import get_system_language
+                        lang = get_system_language()
+                        compacting_message = "compacting..." if lang == "en" else "压缩中..."
+                    except:
+                        compacting_message = "compacting..."
+                    
+                    self._console.print(Panel(
+                        f"[dim]{compacting_message}[/dim]", 
+                        title="🗜️ Compacting", 
+                        border_style="yellow", 
+                        title_align="left"
+                    ))
+                else:
+                    tool_args = event.data.get("args", {})
+                    display_content = self._format_tool_display(tool_name, tool_args)
+                    self._console.print(Panel(
+                        display_content, 
+                        title=f"🛠️ Action: {tool_name}", 
+                        border_style="blue", 
+                        title_align="left"
+                    ))
                 
             elif event.event_type == "tool_result":
                 tool_name = event.data.get("tool_name", "Unknown Tool")
+                
+                # 跳过 ConversationMessageIds 工具的结果显示 - 已由 compacting 消息处理
+                if tool_name in ["ConversationMessageIdsWriteTool", "ConversationMessageIdsReadTool"]:
+                    return
+                
                 success = event.data.get("success", True)
                 message = event.data.get("message", "")
                 content = event.data.get("content")
@@ -343,6 +466,297 @@ class AutoCoderCore:
         except Exception as e:
             # 渲染错误不应该影响主流程
             self._console.print(f"[dim red]Render error: {str(e)}[/dim red]")
+
+    def _render_json_event(self, event: StreamEvent) -> None:
+        """
+        以 JSON 格式渲染流式事件
+        
+        Args:
+            event: 流式事件
+        """
+        try:
+            # 构建事件的 JSON 表示
+            event_json = self._convert_event_to_json(event)
+            print(json.dumps(event_json, ensure_ascii=False), flush=True)
+        except Exception as e:
+            # 如果 JSON 序列化失败，输出错误事件
+            error_json = {
+                "event_type": "json_render_error",
+                "data": {
+                    "error": str(e),
+                    "original_event_type": getattr(event, 'event_type', 'unknown')
+                },
+                "timestamp": time.time()
+            }
+            print(json.dumps(error_json, ensure_ascii=False), flush=True)
+
+    def _convert_event_to_json(self, event: StreamEvent) -> dict:
+        """
+        将流式事件转换为 JSON 字典
+        
+        Args:
+            event: 流式事件
+            
+        Returns:
+            dict: JSON 字典表示
+        """
+        # 处理新格式的事件类型（动态检查以避免导入依赖）
+        event_class_name = type(event).__name__
+        
+        # 基础事件信息
+        base_json = {
+            "timestamp": time.time(),
+        }
+        
+        try:
+            if 'TokenUsageEvent' in event_class_name:
+                usage = getattr(event, 'usage', None)
+                base_json.update({
+                    "event_type": "token_usage",
+                    "data": {
+                        "usage": self._serialize_usage_object(usage) if usage else None
+                    }
+                })
+            elif 'WindowLengthChangeEvent' in event_class_name:
+                tokens_used = getattr(event, 'tokens_used', 0)
+                base_json.update({
+                    "event_type": "window_change",
+                    "data": {
+                        "tokens_used": tokens_used
+                    }
+                })
+            elif 'LLMThinkingEvent' in event_class_name:
+                text = getattr(event, 'text', '')
+                base_json.update({
+                    "event_type": "llm_thinking",
+                    "data": {
+                        "text": text
+                    }
+                })
+            elif 'LLMOutputEvent' in event_class_name:
+                text = getattr(event, 'text', '')
+                base_json.update({
+                    "event_type": "llm_output",
+                    "data": {
+                        "text": text
+                    }
+                })
+            elif 'ToolCallEvent' in event_class_name:
+                tool = getattr(event, 'tool', None)
+                tool_name = type(tool).__name__ if tool else "Unknown Tool"
+                tool_args = self._serialize_tool_object(tool) if tool else {}
+                base_json.update({
+                    "event_type": "tool_call",
+                    "data": {
+                        "tool_name": tool_name,
+                        "args": tool_args
+                    }
+                })
+            elif 'ToolResultEvent' in event_class_name:
+                tool_name = getattr(event, 'tool_name', 'Unknown')
+                result = getattr(event, 'result', None)
+                result_data = self._serialize_tool_result(result) if result else {}
+                base_json.update({
+                    "event_type": "tool_result",
+                    "data": {
+                        "tool_name": tool_name,
+                        **result_data
+                    }
+                })
+            elif 'CompletionEvent' in event_class_name:
+                completion = getattr(event, 'completion', None)
+                completion_data = self._serialize_completion_object(completion) if completion else {}
+                base_json.update({
+                    "event_type": "completion",
+                    "data": completion_data
+                })
+            elif 'PlanModeRespondEvent' in event_class_name:
+                completion = getattr(event, 'completion', None)
+                response = getattr(completion, 'response', 'Plan completed') if completion else 'Plan completed'
+                base_json.update({
+                    "event_type": "plan_mode_respond",
+                    "data": {
+                        "result": response
+                    }
+                })
+            elif 'ErrorEvent' in event_class_name:
+                message = getattr(event, 'message', 'Unknown error')
+                base_json.update({
+                    "event_type": "error",
+                    "data": {
+                        "error": message,
+                        "error_type": "Error"
+                    }
+                })
+            elif 'ConversationIdEvent' in event_class_name:
+                conversation_id = getattr(event, 'conversation_id', '')
+                base_json.update({
+                    "event_type": "conversation_id",
+                    "data": {
+                        "conversation_id": conversation_id
+                    }
+                })
+            elif 'PreCommitEvent' in event_class_name:
+                # event.commit_result 和 event.tpe 一定存在
+                commit_result = event.commit_result
+                commit_data = self._serialize_commit_result(commit_result)
+                base_json.update({
+                    "event_type": "pre_commit",
+                    "data": {
+                        "commit_result": commit_data,
+                        "tpe": event.tpe
+                    }
+                })
+            elif 'CommitEvent' in event_class_name:
+                # event.commit_result 和 event.tpe 一定存在
+                commit_result = event.commit_result
+                commit_data = self._serialize_commit_result(commit_result)
+                base_json.update({
+                    "event_type": "commit",
+                    "data": {
+                        "commit_result": commit_data,
+                        "tpe": event.tpe
+                    }
+                })
+            elif 'PullRequestEvent' in event_class_name:
+                # event.pull_request_result 一定存在
+                pr_result = event.pull_request_result
+                pr_data = self._serialize_pr_result(pr_result)
+                base_json.update({
+                    "event_type": "pull_request",
+                    "data": {
+                        "pull_request_result": pr_data
+                    }
+                })
+            else:
+                # 处理旧格式的事件（有 event_type 和 data 属性）
+                if hasattr(event, 'event_type') and hasattr(event, 'data'):
+                    base_json.update({
+                        "event_type": event.event_type,
+                        "data": event.data if isinstance(event.data, dict) else {"content": str(event.data)}
+                    })
+                else:
+                    # 未知事件类型，尝试序列化所有属性
+                    base_json.update({
+                        "event_type": "unknown",
+                        "data": self._serialize_object_attributes(event)
+                    })
+        except Exception as e:
+            # 如果序列化失败，返回基本信息
+            base_json.update({
+                "event_type": "serialization_error",
+                "data": {
+                    "error": str(e),
+                    "original_class": event_class_name
+                }
+            })
+        
+        return base_json
+
+    def _serialize_usage_object(self, usage) -> dict:
+        """序列化使用情况对象"""
+        try:
+            return {
+                "input_tokens_count": getattr(usage, 'input_tokens_count', 0),
+                "generated_tokens_count": getattr(usage, 'generated_tokens_count', 0),
+                "total_tokens": getattr(usage, 'input_tokens_count', 0) + getattr(usage, 'generated_tokens_count', 0)
+            }
+        except:
+            return {"error": "Failed to serialize usage object"}
+
+    def _serialize_tool_object(self, tool) -> dict:
+        """序列化工具对象"""
+        try:
+            if hasattr(tool, '__dict__'):
+                result = {}
+                for key, value in tool.__dict__.items():
+                    if not key.startswith('_'):
+                        try:
+                            # 尝试序列化值，如果失败则转为字符串
+                            json.dumps(value)
+                            result[key] = value
+                        except:
+                            result[key] = str(value)
+                return result
+            else:
+                return {"tool": str(tool)}
+        except:
+            return {"error": "Failed to serialize tool object"}
+
+    def _serialize_tool_result(self, result) -> dict:
+        """序列化工具结果对象"""
+        try:
+            return {
+                "success": getattr(result, 'success', True),
+                "message": getattr(result, 'message', ''),
+                "content": self._serialize_content(getattr(result, 'content', None))
+            }
+        except:
+            return {"error": "Failed to serialize tool result"}
+
+    def _serialize_completion_object(self, completion) -> dict:
+        """序列化完成对象"""
+        try:
+            return {
+                "result": getattr(completion, 'result', 'Task completed successfully'),
+                "command": getattr(completion, 'command', None)
+            }
+        except:
+            return {"error": "Failed to serialize completion object"}
+
+    def _serialize_content(self, content) -> Any:
+        """序列化内容，确保可以 JSON 序列化"""
+        try:
+            if content is None:
+                return None
+            # 尝试 JSON 序列化测试
+            json.dumps(content)
+            return content
+        except:
+            # 如果不能序列化，转为字符串
+            return str(content)
+
+    def _serialize_object_attributes(self, obj) -> dict:
+        """序列化对象的所有属性"""
+        try:
+            result = {}
+            if hasattr(obj, '__dict__'):
+                for key, value in obj.__dict__.items():
+                    if not key.startswith('_'):
+                        result[key] = self._serialize_content(value)
+            return result
+        except:
+            return {"error": "Failed to serialize object attributes"}
+
+    def _serialize_commit_result(self, commit_result) -> dict:
+        """序列化 Git 提交结果对象"""
+        try:
+            return {
+                "success": commit_result.success if hasattr(commit_result, 'success') else False,
+                "message": commit_result.message if hasattr(commit_result, 'message') else '',
+                "commit_hash": commit_result.commit_hash if hasattr(commit_result, 'commit_hash') else '',
+                "files_changed": commit_result.files_changed if hasattr(commit_result, 'files_changed') else [],
+                "error": commit_result.error if hasattr(commit_result, 'error') else None
+            }
+        except:
+            return {"error": "Failed to serialize commit result"}
+
+    def _serialize_pr_result(self, pr_result) -> dict:
+        """序列化 Pull Request 结果对象"""
+        try:
+            return {
+                "success": pr_result.success if hasattr(pr_result, 'success') else False,
+                "pr_number": pr_result.pr_number if hasattr(pr_result, 'pr_number') else None,
+                "pr_url": pr_result.pr_url if hasattr(pr_result, 'pr_url') else '',
+                "pr_id": pr_result.pr_id if hasattr(pr_result, 'pr_id') else None,
+                "error_message": pr_result.error_message if hasattr(pr_result, 'error_message') else None,
+                "error_code": pr_result.error_code if hasattr(pr_result, 'error_code') else None,
+                "platform": pr_result.platform if hasattr(pr_result, 'platform') else None,
+                "raw_response": self._serialize_content(pr_result.raw_response if hasattr(pr_result, 'raw_response') else None),
+                "retry_after": pr_result.retry_after if hasattr(pr_result, 'retry_after') else None
+            }
+        except:
+            return {"error": "Failed to serialize pull request result"}
     
     def _format_tool_display(self, tool_name: str, tool_args: Dict[str, Any]) -> str:
         """
@@ -471,128 +885,100 @@ class AutoCoderCore:
             return content_str
         
         try:
-            if isinstance(content, (dict, list)):
+            # Remove hints from content before processing
+            processed_content = content
+            if isinstance(content, str) and has_hint_in_text(content):
+                processed_content = extract_content_from_text(content)
+            
+            if isinstance(processed_content, (dict, list)):
                 import json
-                content_str = json.dumps(content, indent=2, ensure_ascii=False)
+                content_str = json.dumps(processed_content, indent=2, ensure_ascii=False)
                 return Syntax(_truncate_content(content_str), "json", theme="default", line_numbers=False)
                 
-            elif isinstance(content, str):
+            elif isinstance(processed_content, str):
                 # 检查是否是多行内容或代码
-                if '\n' in content or content.strip().startswith('<') or len(content) > 200:
+                if '\n' in processed_content or processed_content.strip().startswith('<') or len(processed_content) > 200:
                     # 推断语法类型
                     lexer = "text"
                     if "ReadFile" in tool_name:
-                        if any(ext in content for ext in [".py", "python"]):
+                        if any(ext in processed_content for ext in [".py", "python"]):
                             lexer = "python"
-                        elif any(ext in content for ext in [".js", "javascript"]):
+                        elif any(ext in processed_content for ext in [".js", "javascript"]):
                             lexer = "javascript"
-                        elif any(ext in content for ext in [".ts", "typescript"]):
+                        elif any(ext in processed_content for ext in [".ts", "typescript"]):
                             lexer = "typescript"
-                        elif any(ext in content for ext in [".html", "<!DOCTYPE", "<html"]):
+                        elif any(ext in processed_content for ext in [".html", "<!DOCTYPE", "<html"]):
                             lexer = "html"
-                        elif any(ext in content for ext in [".css", "{"]):
+                        elif any(ext in processed_content for ext in [".css", "{"]):
                             lexer = "css"
-                        elif any(ext in content for ext in [".json", "{"]):
+                        elif any(ext in processed_content for ext in [".json", "{"]):
                             lexer = "json"
-                        elif any(ext in content for ext in [".xml", "<?xml"]):
+                        elif any(ext in processed_content for ext in [".xml", "<?xml"]):
                             lexer = "xml"
-                        elif any(ext in content for ext in [".md", "#"]):
+                        elif any(ext in processed_content for ext in [".md", "#"]):
                             lexer = "markdown"
                     elif "ExecuteCommand" in tool_name or "Shell" in tool_name:
                         lexer = "shell"
-                    elif content.strip().startswith('{') or content.strip().startswith('['):
+                    elif processed_content.strip().startswith('{') or processed_content.strip().startswith('['):
                         lexer = "json"
                     
-                    return Syntax(_truncate_content(content), lexer, theme="default", line_numbers=True)
+                    return Syntax(_truncate_content(processed_content), lexer, theme="default", line_numbers=True)
                 else:
-                    return _truncate_content(content)
+                    return _truncate_content(processed_content)
             else:
-                return _truncate_content(str(content))
+                return _truncate_content(str(processed_content))
                 
         except Exception:
             return _truncate_content(str(content))
     
-    async def query_stream(self, prompt: str, show_terminal: bool = True) -> AsyncIterator[Message]:
+    async def query_stream(self, prompt: str, show_terminal: Optional[bool] = None) -> AsyncIterator[StreamEvent]:
         """
         异步流式查询 - 使用 run_auto_command
         
         Args:
             prompt: 查询提示
-            show_terminal: 是否显示到终端
+            show_terminal: 是否显示到终端，None时使用配置中的verbose设置
             
         Yields:
-            Message: 响应消息流
+            StreamEvent: 响应事件流
             
         Raises:
             BridgeError: 桥接层错误
         """
+        # 如果没有明确指定show_terminal，使用verbose配置
+        if show_terminal is None:
+            show_terminal = self.options.verbose
+        
+        # 如果verbose为False，则强制show_terminal为False
+        if not self.options.verbose:
+            show_terminal = False
+            
         try:
             # 重置累计的 token 使用情况
             self._reset_token_usage()
             
             # 先返回用户消息
-            user_message = Message(role="user", content=prompt)
+            user_message = StreamEvent(event_type="start", data={"query": prompt})
             yield user_message
             
             # 在线程池中执行同步调用
             loop = asyncio.get_event_loop()
             
-            # 使用 run_auto_command 进行代码修改
+            # 使用 run_auto_command 进行代码修改，传递 cancel_token
             event_stream = await loop.run_in_executor(
                 self._executor,
                 self._sync_run_auto_command,
-                prompt
+                prompt,
+                False,  # pre_commit
+                None,   # pr (使用默认值)
+                None    # extra_args
             )
             
-            # 处理事件流并转换为消息
-            assistant_content = ""
+            # 处理事件流并转换为消息            
             for event in event_stream:
                 # 渲染事件到终端
-                self._render_stream_event(event, show_terminal)
-                
-                if event.event_type == "content":
-                    content = event.data.get("content", "")
-                    assistant_content += content
-                    
-                    # 返回增量消息
-                    yield Message(
-                        role="assistant",
-                        content=content,
-                        metadata={
-                            "event_type": event.event_type,
-                            "model": self.options.model,
-                            "temperature": self.options.temperature,
-                            "is_incremental": True
-                        }
-                    )
-                elif event.event_type == "end":
-                    # 返回最终完整消息
-                    yield Message(
-                        role="assistant",
-                        content=assistant_content,
-                        metadata={
-                            "event_type": event.event_type,
-                            "model": self.options.model,
-                            "temperature": self.options.temperature,
-                            "is_final": True,
-                            "status": event.data.get("status", "completed")
-                        }
-                    )
-                elif event.event_type == "error":
-                    # 返回错误消息
-                    yield Message(
-                        role="assistant",
-                        content=f"Error: {event.data.get('error', 'Unknown error')}",
-                        metadata={
-                            "event_type": event.event_type,
-                            "error_type": event.data.get("error_type", "Unknown"),
-                            "is_error": True
-                        }
-                    )
-                    
-                # 添加小延迟以改善视觉效果
-                if show_terminal:
-                    time.sleep(0.05)
+                self._render_stream_event(event, show_terminal)                
+                yield event                                  
             
             # 打印最终的累计 token 使用情况
             if show_terminal:
@@ -604,52 +990,40 @@ class AutoCoderCore:
                 self._print_final_token_usage()
             raise e
     
-    def query_sync(self, prompt: str, show_terminal: bool = True) -> str:
+    def query_sync(self, prompt: str, show_terminal: Optional[bool] = None) -> List[StreamEvent]:
         """
-        同步查询 - 使用 run_auto_command
+        同步查询 - 通过调用 query_stream 实现
         
         Args:
             prompt: 查询提示
-            show_terminal: 是否显示到终端
+            show_terminal: 是否显示到终端，None时使用配置中的verbose设置
             
         Returns:
-            str: 响应内容
+            List[StreamEvent]: 事件列表，包含用户查询和响应事件
             
         Raises:
             BridgeError: 桥接层错误
         """
         try:
-            # 重置累计的 token 使用情况
-            self._reset_token_usage()
+            # 收集所有事件
+            events = []
             
-            event_stream = self._sync_run_auto_command(prompt)
+            # 运行异步查询流并收集结果
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
             
-            # 收集所有内容
-            content_parts = []
-            for event in event_stream:
-                # 渲染事件到终端
-                self._render_stream_event(event, show_terminal)
-                
-                if event.event_type == "content":
-                    content_parts.append(event.data.get("content", ""))
-                elif event.event_type == "error":                                        
-                    raise BridgeError(f"Query failed: {event.data.get('error', 'Unknown error')}")
+            try:
+                async def collect_events():
+                    async for event in self.query_stream(prompt, show_terminal):
+                        events.append(event)
                 
-                # 添加小延迟以改善视觉效果
-                if show_terminal:
-                    time.sleep(0.05)
-            
-            # 打印最终的累计 token 使用情况
-            if show_terminal:
-                self._print_final_token_usage()
+                loop.run_until_complete(collect_events())
+            finally:
+                loop.close()
             
-            return "".join(content_parts)
+            return events
             
         except Exception as e:
-            # 在异常时也打印累计的 token 使用情况
-            if show_terminal:
-                self._print_final_token_usage()
-              
             raise e
         
     def _sync_run_auto_command(
@@ -679,6 +1053,7 @@ class AutoCoderCore:
             query=prompt,
             pre_commit=pre_commit,
             pr=pr,
+            cancel_token=self.options.cancel_token,
             extra_args=extra_args or {},
             stream=True
         )