auto-coder 3.0.41__tar.gz → 3.0.43__tar.gz

{auto_coder-3.0.41/src/auto_coder.egg-info → auto_coder-3.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.41
+Version: 3.0.43
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.41 → auto_coder-3.0.43}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "auto-coder"
-version = "3.0.41"
+version = "3.0.43"
 description = "AutoCoder: AutoCoder"
 authors = [
     {name = "allwefantasy", email = "allwefantasy@gmail.com"}

{auto_coder-3.0.41 → auto_coder-3.0.43/src/auto_coder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.41
+Version: 3.0.43
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.41 → auto_coder-3.0.43}/src/autocoder/common/shells.py

@@ -6,6 +6,7 @@ import platform
 import tempfile
 import uuid
 import re
+from typing import Optional
 from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
@@ -378,7 +379,11 @@ def _win_code_page_to_encoding(code_page: str) -> str:
     return cp_map.get(code_page, f"cp{code_page}")
 
 
-def execute_shell_command(command: str, compact_output: bool = False):
+def execute_shell_command(
+    command: str,
+    compact_output: bool = False,
+    cancel_token: Optional[str] = None,
+):
     """
     Execute a shell command with cross-platform encoding support and streaming output.
 
@@ -387,6 +392,8 @@ def execute_shell_command(command: str, compact_output: bool = False):
         compact_output: If True, print only a minimal terminal-style block:
             ``$ <command>`` with dim ``exit <code>``, then raw stdout/stderr (no temp path,
             no "Output streaming" banner). Used by terminal V3 ``!`` prefix.
+        cancel_token: If provided, register an on_cancel callback to kill the
+            subprocess when the token is cancelled.
     """
     user_command = command
     console = Console()
@@ -458,9 +465,12 @@ set PYTHONIOENCODING=utf-8
         # 创建子进程时设置环境变量
         env = os.environ.copy()
         env["PYTHONIOENCODING"] = "utf-8"
+        env["GIT_PAGER"] = "cat"
+        env["GIT_TERMINAL_PROMPT"] = "0"
 
         process = subprocess.Popen(
             command,
+            stdin=subprocess.DEVNULL,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             shell=True,
@@ -472,6 +482,19 @@ set PYTHONIOENCODING=utf-8
             universal_newlines=True,  # Use text mode to handle platform line endings
         )
 
+        if cancel_token:
+            from autocoder.common.global_cancel import global_cancel
+
+            def _kill_process():
+                try:
+                    process.kill()
+                except Exception:
+                    pass
+
+            global_cancel.on_cancel(cancel_token, _kill_process)
+            if global_cancel.is_requested(cancel_token):
+                _kill_process()
+
         if compact_output:
             stdout_data, stderr_data = process.communicate()
             return_code = process.returncode if process.returncode is not None else 0

{auto_coder-3.0.41 → auto_coder-3.0.43}/src/autocoder/common/v2/agent/runner/file_based_event_runner.py

@@ -19,6 +19,7 @@ from autocoder.common.v2.agent.agentic_edit_types import (
     ToolResultEvent,
     ToolStreamEvent,
     TokenUsageEvent,
+    ModelUsageEvent,
     ErrorEvent,
     PlanModeRespondEvent,
     WindowLengthChangeEvent,
@@ -181,6 +182,36 @@ class FileBasedEventRunner(BaseRunner):
                         content=content.to_dict(), metadata=metadata.to_dict()
                     )
 
+                elif isinstance(agent_event, ModelUsageEvent):
+                    last_meta = agent_event.usage
+                    model_name = agent_event.model_identity.registered_name
+
+                    input_tokens = getattr(last_meta, "input_tokens_count", 0)
+                    output_tokens = getattr(last_meta, "generated_tokens_count", 0)
+                    first_token_time = getattr(last_meta, "first_token_time", 0.0)
+
+                    logger.info(
+                        f"Model Usage Details: Model={model_name}, "
+                        f"Input Tokens={input_tokens}, Output Tokens={output_tokens}, "
+                        f"Input Cost=${agent_event.input_cost:.6f}, Output Cost=${agent_event.output_cost:.6f}"
+                    )
+
+                    metadata.path = "/agent/edit/token_usage"
+                    content = EventContentCreator.create_result(
+                        content=EventContentCreator.ResultTokenStatContent(
+                            model_name=model_name,
+                            elapsed_time=0.0,
+                            first_token_time=first_token_time,
+                            input_tokens=input_tokens,
+                            output_tokens=output_tokens,
+                            input_cost=agent_event.input_cost,
+                            output_cost=agent_event.output_cost,
+                        ).to_dict()
+                    )
+                    event_manager.write_result(
+                        content=content.to_dict(), metadata=metadata.to_dict()
+                    )
+
                 elif isinstance(agent_event, CompletionEvent):
                     # 在这里完成实际合并
                     try:

{auto_coder-3.0.41 → auto_coder-3.0.43}/src/autocoder/terminal_core/cloud_bridge.py

@@ -23,8 +23,10 @@ from loguru import logger
 
 from autocoder.common.v2.agent.agentic_edit_types import (
     ConversationAction,
+    ConversationForwardedEvent,
     ModelUsageEvent,
 )
+from autocoder.common.global_cancel import global_cancel
 from autocoder.terminal_core.cloud_command_dispatcher import (
     CloudCommandDispatcher,
 )
@@ -77,6 +79,7 @@ class PendingRun:
     origin: str
     created_at: str
     files: List[PendingRunFile]
+    forward_to_running: bool = False
 
 
 class CloudBridge:
@@ -121,6 +124,7 @@ class CloudBridge:
         self._running = False
         self._executing_conversations: Dict[str, str] = {}  # conversation_id -> run_id
         self._run_tasks: Dict[str, asyncio.Task] = {}  # run_id -> asyncio.Task
+        self._run_cancel_tokens: Dict[str, str] = {}  # run_id -> cancel_token
 
         project_hash = hashlib.md5(
             (config.project_path or "default").encode()
@@ -311,13 +315,28 @@ class CloudBridge:
             body["currentRunId"] = executing_run_ids[0]
             body["executingRunIds"] = executing_run_ids
         try:
-            await asyncio.get_event_loop().run_in_executor(
+            resp = await asyncio.get_event_loop().run_in_executor(
                 None,
                 lambda: self._session.post(self._url("/api/client/heartbeat"), json=body),
             )
+            if resp.status_code == 200:
+                data = resp.json()
+                for run_id in data.get("cancelRunIds", []):
+                    await self._cancel_run(run_id)
         except Exception as e:
             logger.warning(f"heartbeat error: {e}")
 
+    async def _cancel_run(self, run_id: str):
+        """Cancel a running task by triggering global_cancel on its token."""
+        cancel_token = self._run_cancel_tokens.get(run_id)
+        if cancel_token:
+            logger.info(f"CloudBridge cancelling run {run_id} (token={cancel_token})")
+            global_cancel.cancel(cancel_token)
+        else:
+            logger.warning(
+                f"CloudBridge cancelling run {run_id} but no cancel token was registered"
+            )
+
     # ── 轮询 + 执行 ──────────────────────────────────────
 
     async def _poll_loop(self):
@@ -330,13 +349,20 @@ class CloudBridge:
                 for rid in done_ids:
                     self._run_tasks.pop(rid, None)
 
+                # Reuse the control-plane heartbeat while work is executing so
+                # cancel signals are observed on the same cadence as polling.
+                if self._executing_conversations:
+                    await self._send_heartbeat()
+
                 runs = await self._fetch_pending_runs()
                 for run in runs:
-                    # Skip if this conversation already has an active run
+                    if run.id in self._run_tasks:
+                        continue
                     if run.conversation_id in self._executing_conversations:
+                        if run.forward_to_running:
+                            task = asyncio.create_task(self._safe_forward_run(run))
+                            self._run_tasks[run.id] = task
                         continue
-                    # Mark conversation as executing before creating task to prevent
-                    # the next poll from picking up another run for the same conversation
                     self._executing_conversations[run.conversation_id] = run.id
                     task = asyncio.create_task(self._safe_process_run(run))
                     self._run_tasks[run.id] = task
@@ -375,6 +401,7 @@ class CloudBridge:
                             )
                             for f in r.get("files", [])
                         ],
+                        forward_to_running=r.get("forwardToRunning", False),
                     )
                     for r in items
                 ]
@@ -457,12 +484,76 @@ class CloudBridge:
             self._executing_conversations.pop(run.conversation_id, None)
             self._run_tasks.pop(run.id, None)
 
+    async def _safe_forward_run(self, run: PendingRun):
+        """Wrapper for forwarding input to a running conversation."""
+        try:
+            await self._forward_run(run)
+        except Exception as e:
+            logger.error(f"CloudBridge forward run {run.id} unexpected error: {e}")
+        finally:
+            self._run_tasks.pop(run.id, None)
+
+    async def _forward_run(self, run: PendingRun):
+        """Claim a run and forward its input to the already-running conversation."""
+        claimed = await self._claim_run(run.id)
+        if not claimed:
+            return
+
+        logger.info(
+            f"CloudBridge forwarding run {run.id} to running conv={run.conversation_id}: "
+            f"{run.prompt_text[:80]}"
+        )
+
+        await self._report_result(run.id, "RUNNING")
+
+        local_conv_id = self._conv_map.get(run.conversation_id)
+        if not local_conv_id:
+            await self._report_result(
+                run.id, "FAILED",
+                error_text="No local conversation mapping found for forwarding",
+            )
+            return
+
+        try:
+            result: ExecutionResult = await self._broker.execute_async(
+                query=run.prompt_text,
+                conversation_action=ConversationAction.RESUME,
+                conversation_id=local_conv_id,
+                extra_args={"enable_forward_input_to_running_conversation": True},
+            )
+
+            forwarded = any(
+                isinstance(e, ConversationForwardedEvent) for e in result.events
+            )
+
+            if forwarded:
+                await self._report_result(
+                    run.id, "COMPLETED",
+                    result_text="Input forwarded to running conversation",
+                )
+            elif result.status == RunStatus.COMPLETED:
+                await self._report_result(
+                    run.id, "COMPLETED",
+                    result_text=result.result_text or "",
+                )
+            else:
+                await self._report_result(
+                    run.id, "FAILED",
+                    error_text=result.error_text or "Forward failed",
+                )
+        except Exception as e:
+            logger.error(f"CloudBridge forward run {run.id} failed: {e}")
+            await self._report_result(run.id, "FAILED", error_text=str(e))
+
     async def _process_run(self, run: PendingRun):
         """认领 → 执行 → 回传"""
         claimed = await self._claim_run(run.id)
         if not claimed:
             return
 
+        cancel_token = f"cloud-run-{run.id}"
+        self._run_cancel_tokens[run.id] = cancel_token
+
         logger.info(f"CloudBridge executing run {run.id} (conv={run.conversation_id}): {run.prompt_text[:80]}")
 
         await self._report_result(run.id, "RUNNING")
@@ -471,7 +562,7 @@ class CloudBridge:
             await self._download_run_files(run)
 
         if self._command_dispatcher.is_command(run.prompt_text):
-            await self._process_command_run(run)
+            await self._process_command_run(run, cancel_token)
             return
 
         local_conv_id = self._conv_map.get(run.conversation_id)
@@ -493,6 +584,7 @@ class CloudBridge:
                 query=run.prompt_text,
                 conversation_action=conv_action,
                 conversation_id=local_conv_id,
+                cancel_token=cancel_token,
                 on_event=_on_event,
             )
 
@@ -514,7 +606,7 @@ class CloudBridge:
                     usage_details=usage_details or None,
                 )
             elif result.status == RunStatus.CANCELLED:
-                await self._report_result(run.id, "FAILED", error_text="Cancelled by user", usage_details=usage_details or None)
+                await self._report_result(run.id, "CANCELLED", usage_details=usage_details or None)
             else:
                 await self._report_result(
                     run.id,
@@ -525,15 +617,27 @@ class CloudBridge:
         except Exception as e:
             logger.error(f"CloudBridge run {run.id} failed: {e}")
             await self._report_result(run.id, "FAILED", error_text=str(e))
+        finally:
+            global_cancel.reset_token(cancel_token)
+            self._run_cancel_tokens.pop(run.id, None)
 
-    async def _process_command_run(self, run: PendingRun):
+    async def _process_command_run(self, run: PendingRun, cancel_token: Optional[str] = None):
         """处理斜杠命令类型的 run（如 /commit），在线程池中执行后回传结果。"""
+        cancel_token = cancel_token or f"cloud-run-{run.id}"
+        global_cancel.register_token(cancel_token)
+        self._run_cancel_tokens[run.id] = cancel_token
+
         try:
             loop = asyncio.get_event_loop()
             cmd_result = await loop.run_in_executor(
-                None, self._command_dispatcher.dispatch, run.prompt_text
+                None,
+                lambda: self._command_dispatcher.dispatch(
+                    run.prompt_text, cancel_token=cancel_token
+                ),
             )
-            if cmd_result.error_text:
+            if global_cancel.is_requested(cancel_token):
+                await self._report_result(run.id, "CANCELLED")
+            elif cmd_result.error_text:
                 await self._report_result(
                     run.id, "FAILED", error_text=cmd_result.error_text
                 )
@@ -544,3 +648,6 @@ class CloudBridge:
         except Exception as e:
             logger.error(f"CloudBridge command run {run.id} failed: {e}")
             await self._report_result(run.id, "FAILED", error_text=str(e))
+        finally:
+            global_cancel.reset_token(cancel_token)
+            self._run_cancel_tokens.pop(run.id, None)

{auto_coder-3.0.41 → auto_coder-3.0.43}/src/autocoder/terminal_core/cloud_command_dispatcher.py

@@ -10,12 +10,12 @@ CloudCommandDispatcher - 云端命令分发器
 """
 
 from dataclasses import dataclass
-from typing import Callable, Dict, Optional
+from typing import Any, Callable, Dict, Optional
 
 from loguru import logger
 
 
-CommandHandler = Callable[[str], str]
+CommandHandler = Callable[..., str]
 
 
 @dataclass
@@ -68,7 +68,9 @@ class CloudCommandDispatcher:
         cmd_word = text.split()[0]
         return cmd_word in self._handlers
 
-    def dispatch(self, prompt_text: str) -> CommandResult:
+    def dispatch(
+        self, prompt_text: str, cancel_token: Optional[str] = None
+    ) -> CommandResult:
         text = prompt_text.strip()
 
         for prefix, handler in self._prefix_handlers.items():
@@ -76,7 +78,7 @@ class CloudCommandDispatcher:
                 args = text[len(prefix):].strip()
                 logger.info(f"CloudCommandDispatcher: executing prefix '{prefix}'")
                 try:
-                    result_text = handler(args)
+                    result_text = handler(args, cancel_token=cancel_token)
                     return CommandResult(handled=True, result_text=result_text)
                 except Exception as e:
                     logger.error(f"CloudCommandDispatcher: prefix '{prefix}' failed: {e}")
@@ -707,7 +709,7 @@ def _rules_list(
 # ── !shell ────────────────────────────────────────────────
 
 
-def _handle_shell(args: str) -> str:
+def _handle_shell(args: str, cancel_token: Optional[str] = None) -> str:
     """执行 !<shell command>，对齐 TUI V3 的 ! 前缀行为。"""
     if not args:
         return "Please provide a shell command after '!'."
@@ -717,8 +719,9 @@ def _handle_shell(args: str) -> str:
 
     try:
         with capture_output() as (out, err):
-            # TUI V3 的 `!` 前缀最终会走这里，并启用 compact_output。
-            execute_shell_command(args, compact_output=True)
+            execute_shell_command(
+                args, compact_output=True, cancel_token=cancel_token
+            )
         stdout_text = out.getvalue().strip()
         stderr_text = err.getvalue().strip()
         parts = [p for p in [stdout_text, stderr_text] if p]
@@ -730,7 +733,7 @@ def _handle_shell(args: str) -> str:
 # ── $workflow ─────────────────────────────────────────────
 
 
-def _handle_workflow_shortcut(args: str) -> str:
+def _handle_workflow_shortcut(args: str, **kwargs: Any) -> str:
     """执行 $<workflow-name> <query>，对齐 TUI V3 的 $ 前缀行为。"""
     if not args:
         return _workflow_help()

{auto_coder-3.0.41 → auto_coder-3.0.43}/src/autocoder/version.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = "3.0.41"
+__version__ = "3.0.43"